// $ANTLR 3.1 src/Fibitos.g 2008-09-26 12:24:30

	import java.util.Map;
	import java.util.TreeMap;
	import java.util.HashMap;
	import java.util.List;
	import java.util.LinkedList;
	
	import util.Attribute;
	import util.Result;
	import util.Type;
	import util.Reference;
	import util.Class;
	import util.Selector;
	import util.Scope;
	import util.MethodCall;
	import util.Method;
	
	import statement.*;
	import expression.*;
	import exception.*;
	
	import runtime.ClassMapFactory;
	
	import expression.primary.*;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;


import org.antlr.runtime.tree.*;

public class FibitosParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "COMMENT", "LINE_COMMENT", "WS", "IntegerTypeSuffix", "INTLIT", "Exponent", "DoubleTypeSuffix", "DOUBLELIT", "CHARLIT", "STRINGLIT", "CLASS_IDENT", "IDENT", "DOT", "ASSIGN", "COLON", "SEMI", "COMMA", "EQUALS", "LBRACKET", "RBRACKET", "LBRACE", "RBRACE", "DOTDOT", "LPAREN", "RPAREN", "NOT_EQUALS", "LTE", "LT", "GTE", "GT", "PLUS", "MINUS", "TIMES", "DIV", "MOD", "'class'", "'int'", "'double'", "'char'", "'bool'", "'string'", "'if'", "'else'", "'while'", "'return'", "'||'", "'&&'", "'!'", "'new'", "'true'", "'false'"
    };
    public static final int DoubleTypeSuffix=10;
    public static final int LT=31;
    public static final int MOD=38;
    public static final int GTE=32;
    public static final int LBRACE=24;
    public static final int Exponent=9;
    public static final int EQUALS=21;
    public static final int DOTDOT=26;
    public static final int EOF=-1;
    public static final int LTE=30;
    public static final int NOT_EQUALS=29;
    public static final int LPAREN=27;
    public static final int LBRACKET=22;
    public static final int RPAREN=28;
    public static final int T__51=51;
    public static final int T__52=52;
    public static final int T__53=53;
    public static final int T__54=54;
    public static final int COMMA=20;
    public static final int IDENT=15;
    public static final int PLUS=34;
    public static final int RBRACKET=23;
    public static final int COMMENT=4;
    public static final int DOT=16;
    public static final int T__50=50;
    public static final int STRINGLIT=13;
    public static final int T__42=42;
    public static final int T__43=43;
    public static final int T__40=40;
    public static final int T__41=41;
    public static final int DOUBLELIT=11;
    public static final int T__46=46;
    public static final int T__47=47;
    public static final int T__44=44;
    public static final int RBRACE=25;
    public static final int T__45=45;
    public static final int LINE_COMMENT=5;
    public static final int IntegerTypeSuffix=7;
    public static final int CLASS_IDENT=14;
    public static final int T__48=48;
    public static final int T__49=49;
    public static final int CHARLIT=12;
    public static final int MINUS=35;
    public static final int SEMI=19;
    public static final int COLON=18;
    public static final int WS=6;
    public static final int INTLIT=8;
    public static final int T__39=39;
    public static final int ASSIGN=17;
    public static final int GT=33;
    public static final int DIV=37;
    public static final int TIMES=36;

    // delegates
    // delegators


        public FibitosParser(TokenStream input) {
            this(input, new RecognizerSharedState());
        }
        public FibitosParser(TokenStream input, RecognizerSharedState state) {
            super(input, state);
             
        }
        
    protected TreeAdaptor adaptor = new CommonTreeAdaptor();

    public void setTreeAdaptor(TreeAdaptor adaptor) {
        this.adaptor = adaptor;
    }
    public TreeAdaptor getTreeAdaptor() {
        return adaptor;
    }

    public String[] getTokenNames() { return FibitosParser.tokenNames; }
    public String getGrammarFileName() { return "src/Fibitos.g"; }


    	int lineNo=1;
    	LinkedList<Method> methodStack = new LinkedList<Method>();
    	LinkedList<Class> classStack = new LinkedList<Class>();
    	LinkedList<Scope> scopeStack = new LinkedList<Scope>();


    public static class main_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "main"
    // src/Fibitos.g:159:1: main : p= program ;
    public final FibitosParser.main_return main() throws RecognitionException {
        FibitosParser.main_return retval = new FibitosParser.main_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        FibitosParser.program_return p = null;



        try {
            // src/Fibitos.g:159:6: (p= program )
            // src/Fibitos.g:160:2: p= program
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_program_in_main737);
            p=program();

            state._fsp--;

            adaptor.addChild(root_0, p.getTree());

            		(p!=null?p.program:null).run();
            	

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "main"

    public static class program_return extends ParserRuleReturnScope {
        public Program program;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "program"
    // src/Fibitos.g:165:1: program returns [Program program] : cd= classDeclarations sb= scriptBody ;
    public final FibitosParser.program_return program() throws RecognitionException {
        FibitosParser.program_return retval = new FibitosParser.program_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        FibitosParser.classDeclarations_return cd = null;

        FibitosParser.scriptBody_return sb = null;



        try {
            // src/Fibitos.g:166:2: (cd= classDeclarations sb= scriptBody )
            // src/Fibitos.g:167:4: cd= classDeclarations sb= scriptBody
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_classDeclarations_in_program759);
            cd=classDeclarations();

            state._fsp--;

            adaptor.addChild(root_0, cd.getTree());
             ClassMapFactory.getInstance().setClassMap((cd!=null?cd.classMap:null)); 
            pushFollow(FOLLOW_scriptBody_in_program772);
            sb=scriptBody();

            state._fsp--;

            adaptor.addChild(root_0, sb.getTree());
             retval.program = new Program((sb!=null?sb.attributes:null), (sb!=null?sb.statements:null)); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "program"

    public static class classDeclarations_return extends ParserRuleReturnScope {
        public Map<String, Class> classMap;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "classDeclarations"
    // src/Fibitos.g:173:1: classDeclarations returns [Map<String, Class> classMap] : (c= classDeclaration )* ;
    public final FibitosParser.classDeclarations_return classDeclarations() throws RecognitionException {
        FibitosParser.classDeclarations_return retval = new FibitosParser.classDeclarations_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        FibitosParser.classDeclaration_return c = null;



        try {
            // src/Fibitos.g:174:2: ( (c= classDeclaration )* )
            // src/Fibitos.g:175:2: (c= classDeclaration )*
            {
            root_0 = (CommonTree)adaptor.nil();

             retval.classMap = new HashMap<String, Class>(); 
            // src/Fibitos.g:176:4: (c= classDeclaration )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==39) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // src/Fibitos.g:176:5: c= classDeclaration
            	    {
            	    pushFollow(FOLLOW_classDeclaration_in_classDeclarations801);
            	    c=classDeclaration();

            	    state._fsp--;

            	    adaptor.addChild(root_0, c.getTree());
            	     retval.classMap.put((c!=null?c.c:null).getName(), (c!=null?c.c:null)); 

            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "classDeclarations"

    public static class classDeclaration_return extends ParserRuleReturnScope {
        public Class c;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "classDeclaration"
    // src/Fibitos.g:179:1: classDeclaration returns [Class c] : 'class' id= CLASS_IDENT LBRACE (attr= attribute_declaration )* (m= method_declaration )* RBRACE ;
    public final FibitosParser.classDeclaration_return classDeclaration() throws RecognitionException {
        FibitosParser.classDeclaration_return retval = new FibitosParser.classDeclaration_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token id=null;
        Token string_literal1=null;
        Token LBRACE2=null;
        Token RBRACE3=null;
        FibitosParser.attribute_declaration_return attr = null;

        FibitosParser.method_declaration_return m = null;


        CommonTree id_tree=null;
        CommonTree string_literal1_tree=null;
        CommonTree LBRACE2_tree=null;
        CommonTree RBRACE3_tree=null;

        try {
            // src/Fibitos.g:180:2: ( 'class' id= CLASS_IDENT LBRACE (attr= attribute_declaration )* (m= method_declaration )* RBRACE )
            // src/Fibitos.g:181:4: 'class' id= CLASS_IDENT LBRACE (attr= attribute_declaration )* (m= method_declaration )* RBRACE
            {
            root_0 = (CommonTree)adaptor.nil();

            string_literal1=(Token)match(input,39,FOLLOW_39_in_classDeclaration824); 
            string_literal1_tree = (CommonTree)adaptor.create(string_literal1);
            adaptor.addChild(root_0, string_literal1_tree);

            id=(Token)match(input,CLASS_IDENT,FOLLOW_CLASS_IDENT_in_classDeclaration828); 
            id_tree = (CommonTree)adaptor.create(id);
            adaptor.addChild(root_0, id_tree);

            LBRACE2=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_classDeclaration833); 
            LBRACE2_tree = (CommonTree)adaptor.create(LBRACE2);
            adaptor.addChild(root_0, LBRACE2_tree);

             Map<String, Attribute> attributes = new HashMap<String, Attribute>(); 
             Map<String, Method> methods = new HashMap<String, Method>(); 
             retval.c = new Class((id!=null?id.getText():null), attributes, methods); 
             Scope scope = new Scope(null); 
             classStack.add(retval.c); 
            // src/Fibitos.g:188:4: (attr= attribute_declaration )*
            loop2:
            do {
                int alt2=2;
                alt2 = dfa2.predict(input);
                switch (alt2) {
            	case 1 :
            	    // src/Fibitos.g:188:5: attr= attribute_declaration
            	    {
            	    pushFollow(FOLLOW_attribute_declaration_in_classDeclaration867);
            	    attr=attribute_declaration();

            	    state._fsp--;

            	    adaptor.addChild(root_0, attr.getTree());
            	     attributes.put((attr!=null?attr.attribute:null).getName(), (attr!=null?attr.attribute:null)); 
            	    	  	scope.addReference(new Reference(attr.attribute)); 

            	    }
            	    break;

            	default :
            	    break loop2;
                }
            } while (true);

             scopeStack.add(scope); 
            // src/Fibitos.g:191:4: (m= method_declaration )*
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( (LA3_0==CLASS_IDENT||(LA3_0>=40 && LA3_0<=44)) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // src/Fibitos.g:191:5: m= method_declaration
            	    {
            	    pushFollow(FOLLOW_method_declaration_in_classDeclaration884);
            	    m=method_declaration();

            	    state._fsp--;

            	    adaptor.addChild(root_0, m.getTree());
            	     methods.put((m!=null?m.method:null).getMethodName(), (m!=null?m.method:null)); 

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);

             scopeStack.getLast(); 
             classStack.getLast(); 
            RBRACE3=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_classDeclaration905); 
            RBRACE3_tree = (CommonTree)adaptor.create(RBRACE3);
            adaptor.addChild(root_0, RBRACE3_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "classDeclaration"

    public static class method_declaration_return extends ParserRuleReturnScope {
        public Method method;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "method_declaration"
    // src/Fibitos.g:197:1: method_declaration returns [ Method method ] : t= type IDENT LPAREN arglist RPAREN LBRACE (dec= attribute_declaration )* (s= statement )* RBRACE ;
    public final FibitosParser.method_declaration_return method_declaration() throws RecognitionException {
        FibitosParser.method_declaration_return retval = new FibitosParser.method_declaration_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token IDENT4=null;
        Token LPAREN5=null;
        Token RPAREN7=null;
        Token LBRACE8=null;
        Token RBRACE9=null;
        FibitosParser.type_return t = null;

        FibitosParser.attribute_declaration_return dec = null;

        FibitosParser.statement_return s = null;

        FibitosParser.arglist_return arglist6 = null;


        CommonTree IDENT4_tree=null;
        CommonTree LPAREN5_tree=null;
        CommonTree RPAREN7_tree=null;
        CommonTree LBRACE8_tree=null;
        CommonTree RBRACE9_tree=null;

        try {
            // src/Fibitos.g:198:2: (t= type IDENT LPAREN arglist RPAREN LBRACE (dec= attribute_declaration )* (s= statement )* RBRACE )
            // src/Fibitos.g:199:3: t= type IDENT LPAREN arglist RPAREN LBRACE (dec= attribute_declaration )* (s= statement )* RBRACE
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_type_in_method_declaration925);
            t=type();

            state._fsp--;

            adaptor.addChild(root_0, t.getTree());
             Type type = (t!=null?t.type:null); 
            IDENT4=(Token)match(input,IDENT,FOLLOW_IDENT_in_method_declaration928); 
            IDENT4_tree = (CommonTree)adaptor.create(IDENT4);
            adaptor.addChild(root_0, IDENT4_tree);

             String name = (IDENT4!=null?IDENT4.getText():null); 
            LPAREN5=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_method_declaration932); 
            LPAREN5_tree = (CommonTree)adaptor.create(LPAREN5);
            adaptor.addChild(root_0, LPAREN5_tree);

            pushFollow(FOLLOW_arglist_in_method_declaration934);
            arglist6=arglist();

            state._fsp--;

            adaptor.addChild(root_0, arglist6.getTree());
            RPAREN7=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_method_declaration936); 
            RPAREN7_tree = (CommonTree)adaptor.create(RPAREN7);
            adaptor.addChild(root_0, RPAREN7_tree);

            LBRACE8=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_method_declaration940); 
            LBRACE8_tree = (CommonTree)adaptor.create(LBRACE8);
            adaptor.addChild(root_0, LBRACE8_tree);

             List<Attribute> args = (arglist6!=null?arglist6.args:null); 
             List<Attribute> declarations = new LinkedList<Attribute>(); 
             List<Statement> statements = new LinkedList<Statement>(); 
             retval.method = new Method(classStack.peekLast(), type, name, args, declarations, statements); 
             Scope scope = new Scope(scopeStack.peekLast()); 
             methodStack.add(retval.method); 
            // src/Fibitos.g:207:3: (dec= attribute_declaration )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( (LA4_0==CLASS_IDENT||(LA4_0>=40 && LA4_0<=44)) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // src/Fibitos.g:207:4: dec= attribute_declaration
            	    {
            	    pushFollow(FOLLOW_attribute_declaration_in_method_declaration972);
            	    dec=attribute_declaration();

            	    state._fsp--;

            	    adaptor.addChild(root_0, dec.getTree());
            	     declarations.add(dec.attribute);
            	    			scope.addReference(new Reference((dec!=null?dec.attribute:null))); 

            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);

             scopeStack.add(scope); 
            // src/Fibitos.g:210:3: (s= statement )*
            loop5:
            do {
                int alt5=2;
                int LA5_0 = input.LA(1);

                if ( (LA5_0==IDENT||LA5_0==45||(LA5_0>=47 && LA5_0<=48)) ) {
                    alt5=1;
                }


                switch (alt5) {
            	case 1 :
            	    // src/Fibitos.g:210:4: s= statement
            	    {
            	    pushFollow(FOLLOW_statement_in_method_declaration988);
            	    s=statement();

            	    state._fsp--;

            	    adaptor.addChild(root_0, s.getTree());
            	     statements.add(s.statement); 

            	    }
            	    break;

            	default :
            	    break loop5;
                }
            } while (true);

             scopeStack.getLast(); 
             methodStack.getLast(); 
            RBRACE9=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_method_declaration1006); 
            RBRACE9_tree = (CommonTree)adaptor.create(RBRACE9);
            adaptor.addChild(root_0, RBRACE9_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "method_declaration"

    public static class attribute_declaration_return extends ParserRuleReturnScope {
        public Attribute attribute;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "attribute_declaration"
    // src/Fibitos.g:216:1: attribute_declaration returns [Attribute attribute] : type IDENT ';' ;
    public final FibitosParser.attribute_declaration_return attribute_declaration() throws RecognitionException {
        FibitosParser.attribute_declaration_return retval = new FibitosParser.attribute_declaration_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token IDENT11=null;
        Token char_literal12=null;
        FibitosParser.type_return type10 = null;


        CommonTree IDENT11_tree=null;
        CommonTree char_literal12_tree=null;

        try {
            // src/Fibitos.g:217:2: ( type IDENT ';' )
            // src/Fibitos.g:218:3: type IDENT ';'
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_type_in_attribute_declaration1023);
            type10=type();

            state._fsp--;

            adaptor.addChild(root_0, type10.getTree());
            IDENT11=(Token)match(input,IDENT,FOLLOW_IDENT_in_attribute_declaration1025); 
            IDENT11_tree = (CommonTree)adaptor.create(IDENT11);
            adaptor.addChild(root_0, IDENT11_tree);

            retval.attribute = new Attribute((IDENT11!=null?IDENT11.getText():null), (type10!=null?type10.type:null));
            char_literal12=(Token)match(input,SEMI,FOLLOW_SEMI_in_attribute_declaration1029); 
            char_literal12_tree = (CommonTree)adaptor.create(char_literal12);
            adaptor.addChild(root_0, char_literal12_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "attribute_declaration"

    public static class type_return extends ParserRuleReturnScope {
        public Type type;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "type"
    // src/Fibitos.g:221:1: type returns [Type type] : typename= ( 'int' | 'double' | 'char' | 'bool' | 'string' | CLASS_IDENT ) ( LBRACKET INTLIT RBRACKET )? ;
    public final FibitosParser.type_return type() throws RecognitionException {
        FibitosParser.type_return retval = new FibitosParser.type_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token typename=null;
        Token LBRACKET13=null;
        Token INTLIT14=null;
        Token RBRACKET15=null;

        CommonTree typename_tree=null;
        CommonTree LBRACKET13_tree=null;
        CommonTree INTLIT14_tree=null;
        CommonTree RBRACKET15_tree=null;

        try {
            // src/Fibitos.g:222:2: (typename= ( 'int' | 'double' | 'char' | 'bool' | 'string' | CLASS_IDENT ) ( LBRACKET INTLIT RBRACKET )? )
            // src/Fibitos.g:223:3: typename= ( 'int' | 'double' | 'char' | 'bool' | 'string' | CLASS_IDENT ) ( LBRACKET INTLIT RBRACKET )?
            {
            root_0 = (CommonTree)adaptor.nil();

            int size = -1;
            typename=(Token)input.LT(1);
            if ( input.LA(1)==CLASS_IDENT||(input.LA(1)>=40 && input.LA(1)<=44) ) {
                input.consume();
                adaptor.addChild(root_0, (CommonTree)adaptor.create(typename));
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }

            // src/Fibitos.g:224:76: ( LBRACKET INTLIT RBRACKET )?
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0==LBRACKET) ) {
                alt6=1;
            }
            switch (alt6) {
                case 1 :
                    // src/Fibitos.g:224:78: LBRACKET INTLIT RBRACKET
                    {
                    LBRACKET13=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_type1081); 
                    LBRACKET13_tree = (CommonTree)adaptor.create(LBRACKET13);
                    adaptor.addChild(root_0, LBRACKET13_tree);

                    INTLIT14=(Token)match(input,INTLIT,FOLLOW_INTLIT_in_type1083); 
                    INTLIT14_tree = (CommonTree)adaptor.create(INTLIT14);
                    adaptor.addChild(root_0, INTLIT14_tree);

                    RBRACKET15=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_type1085); 
                    RBRACKET15_tree = (CommonTree)adaptor.create(RBRACKET15);
                    adaptor.addChild(root_0, RBRACKET15_tree);

                    size = Integer.parseInt((INTLIT14!=null?INTLIT14.getText():null));

                    }
                    break;

            }


            			if(size > -1)
            				retval.type = new Type((typename!=null?typename.getText():null), true, size);
            			else
            				retval.type = new Type((typename!=null?typename.getText():null), false);
            		

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "type"

    public static class arglist_return extends ParserRuleReturnScope {
        public List<Attribute> args;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "arglist"
    // src/Fibitos.g:233:1: arglist returns [List<Attribute> args] : (t= type id= IDENT ( ',' t2= type id2= IDENT )* )? ;
    public final FibitosParser.arglist_return arglist() throws RecognitionException {
        FibitosParser.arglist_return retval = new FibitosParser.arglist_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token id=null;
        Token id2=null;
        Token char_literal16=null;
        FibitosParser.type_return t = null;

        FibitosParser.type_return t2 = null;


        CommonTree id_tree=null;
        CommonTree id2_tree=null;
        CommonTree char_literal16_tree=null;

        try {
            // src/Fibitos.g:234:2: ( (t= type id= IDENT ( ',' t2= type id2= IDENT )* )? )
            // src/Fibitos.g:235:3: (t= type id= IDENT ( ',' t2= type id2= IDENT )* )?
            {
            root_0 = (CommonTree)adaptor.nil();

            retval.args = new LinkedList<Attribute>(); 
            // src/Fibitos.g:236:3: (t= type id= IDENT ( ',' t2= type id2= IDENT )* )?
            int alt8=2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0==CLASS_IDENT||(LA8_0>=40 && LA8_0<=44)) ) {
                alt8=1;
            }
            switch (alt8) {
                case 1 :
                    // src/Fibitos.g:236:5: t= type id= IDENT ( ',' t2= type id2= IDENT )*
                    {
                    pushFollow(FOLLOW_type_in_arglist1119);
                    t=type();

                    state._fsp--;

                    adaptor.addChild(root_0, t.getTree());
                    id=(Token)match(input,IDENT,FOLLOW_IDENT_in_arglist1123); 
                    id_tree = (CommonTree)adaptor.create(id);
                    adaptor.addChild(root_0, id_tree);

                     retval.args.add(new Attribute((id!=null?id.getText():null), (t!=null?t.type:null))); 
                    // src/Fibitos.g:237:3: ( ',' t2= type id2= IDENT )*
                    loop7:
                    do {
                        int alt7=2;
                        int LA7_0 = input.LA(1);

                        if ( (LA7_0==COMMA) ) {
                            alt7=1;
                        }


                        switch (alt7) {
                    	case 1 :
                    	    // src/Fibitos.g:237:4: ',' t2= type id2= IDENT
                    	    {
                    	    char_literal16=(Token)match(input,COMMA,FOLLOW_COMMA_in_arglist1130); 
                    	    char_literal16_tree = (CommonTree)adaptor.create(char_literal16);
                    	    adaptor.addChild(root_0, char_literal16_tree);

                    	    pushFollow(FOLLOW_type_in_arglist1134);
                    	    t2=type();

                    	    state._fsp--;

                    	    adaptor.addChild(root_0, t2.getTree());
                    	    id2=(Token)match(input,IDENT,FOLLOW_IDENT_in_arglist1138); 
                    	    id2_tree = (CommonTree)adaptor.create(id2);
                    	    adaptor.addChild(root_0, id2_tree);

                    	     retval.args.add(new Attribute((id2!=null?id2.getText():null), (t2!=null?t2.type:null))); 

                    	    }
                    	    break;

                    	default :
                    	    break loop7;
                        }
                    } while (true);


                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "arglist"

    public static class scriptBody_return extends ParserRuleReturnScope {
        public List<Attribute> attributes;
        public List<Statement> statements;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "scriptBody"
    // src/Fibitos.g:240:1: scriptBody returns [List<Attribute> attributes, List<Statement> statements] : (a= attribute_declaration )* (s= statement )* ;
    public final FibitosParser.scriptBody_return scriptBody() throws RecognitionException {
        FibitosParser.scriptBody_return retval = new FibitosParser.scriptBody_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        FibitosParser.attribute_declaration_return a = null;

        FibitosParser.statement_return s = null;



        try {
            // src/Fibitos.g:241:2: ( (a= attribute_declaration )* (s= statement )* )
            // src/Fibitos.g:242:2: (a= attribute_declaration )* (s= statement )*
            {
            root_0 = (CommonTree)adaptor.nil();

             Scope scope = new Scope(null); 
             retval.attributes = new LinkedList<Attribute>(); 
             retval.statements = new LinkedList<Statement>(); 
            // src/Fibitos.g:245:2: (a= attribute_declaration )*
            loop9:
            do {
                int alt9=2;
                int LA9_0 = input.LA(1);

                if ( (LA9_0==CLASS_IDENT||(LA9_0>=40 && LA9_0<=44)) ) {
                    alt9=1;
                }


                switch (alt9) {
            	case 1 :
            	    // src/Fibitos.g:245:3: a= attribute_declaration
            	    {
            	    pushFollow(FOLLOW_attribute_declaration_in_scriptBody1174);
            	    a=attribute_declaration();

            	    state._fsp--;

            	    adaptor.addChild(root_0, a.getTree());
            	     retval.attributes.add((a!=null?a.attribute:null)); scope.addReference(new Reference((a!=null?a.attribute:null)));

            	    }
            	    break;

            	default :
            	    break loop9;
                }
            } while (true);

             scopeStack.add(scope); 
            // src/Fibitos.g:247:2: (s= statement )*
            loop10:
            do {
                int alt10=2;
                int LA10_0 = input.LA(1);

                if ( (LA10_0==IDENT||LA10_0==45||(LA10_0>=47 && LA10_0<=48)) ) {
                    alt10=1;
                }


                switch (alt10) {
            	case 1 :
            	    // src/Fibitos.g:247:3: s= statement
            	    {
            	    pushFollow(FOLLOW_statement_in_scriptBody1187);
            	    s=statement();

            	    state._fsp--;

            	    adaptor.addChild(root_0, s.getTree());
            	     retval.statements.add((s!=null?s.statement:null)); 

            	    }
            	    break;

            	default :
            	    break loop10;
                }
            } while (true);

             scopeStack.getLast(); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "scriptBody"

    public static class statement_return extends ParserRuleReturnScope {
        public Statement statement;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "statement"
    // src/Fibitos.g:251:1: statement returns [Statement statement] : (a= assignmentStatement | i= ifStatement | w= whileStatement | r= returnStatement );
    public final FibitosParser.statement_return statement() throws RecognitionException {
        FibitosParser.statement_return retval = new FibitosParser.statement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        FibitosParser.assignmentStatement_return a = null;

        FibitosParser.ifStatement_return i = null;

        FibitosParser.whileStatement_return w = null;

        FibitosParser.returnStatement_return r = null;



        try {
            // src/Fibitos.g:252:2: (a= assignmentStatement | i= ifStatement | w= whileStatement | r= returnStatement )
            int alt11=4;
            switch ( input.LA(1) ) {
            case IDENT:
                {
                alt11=1;
                }
                break;
            case 45:
                {
                alt11=2;
                }
                break;
            case 47:
                {
                alt11=3;
                }
                break;
            case 48:
                {
                alt11=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;
            }

            switch (alt11) {
                case 1 :
                    // src/Fibitos.g:252:4: a= assignmentStatement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_assignmentStatement_in_statement1211);
                    a=assignmentStatement();

                    state._fsp--;

                    adaptor.addChild(root_0, a.getTree());
                     retval.statement = (a!=null?a.statement:null); 

                    }
                    break;
                case 2 :
                    // src/Fibitos.g:253:4: i= ifStatement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_ifStatement_in_statement1220);
                    i=ifStatement();

                    state._fsp--;

                    adaptor.addChild(root_0, i.getTree());
                     retval.statement = (i!=null?i.statement:null); 

                    }
                    break;
                case 3 :
                    // src/Fibitos.g:254:4: w= whileStatement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_whileStatement_in_statement1229);
                    w=whileStatement();

                    state._fsp--;

                    adaptor.addChild(root_0, w.getTree());
                     retval.statement = (w!=null?w.statement:null); 

                    }
                    break;
                case 4 :
                    // src/Fibitos.g:255:4: r= returnStatement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_returnStatement_in_statement1238);
                    r=returnStatement();

                    state._fsp--;

                    adaptor.addChild(root_0, r.getTree());
                     retval.statement = (r!=null?r.statement:null); 

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "statement"

    public static class assignmentStatement_return extends ParserRuleReturnScope {
        public Statement statement;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "assignmentStatement"
    // src/Fibitos.g:258:1: assignmentStatement returns [Statement statement] : v= variable ASSIGN e= expression ';' ;
    public final FibitosParser.assignmentStatement_return assignmentStatement() throws RecognitionException {
        FibitosParser.assignmentStatement_return retval = new FibitosParser.assignmentStatement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token ASSIGN17=null;
        Token char_literal18=null;
        FibitosParser.variable_return v = null;

        FibitosParser.expression_return e = null;


        CommonTree ASSIGN17_tree=null;
        CommonTree char_literal18_tree=null;

        try {
            // src/Fibitos.g:259:2: (v= variable ASSIGN e= expression ';' )
            // src/Fibitos.g:260:5: v= variable ASSIGN e= expression ';'
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_variable_in_assignmentStatement1261);
            v=variable();

            state._fsp--;

            adaptor.addChild(root_0, v.getTree());
            ASSIGN17=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_assignmentStatement1263); 
            ASSIGN17_tree = (CommonTree)adaptor.create(ASSIGN17);
            adaptor.addChild(root_0, ASSIGN17_tree);

            pushFollow(FOLLOW_expression_in_assignmentStatement1267);
            e=expression();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
            char_literal18=(Token)match(input,SEMI,FOLLOW_SEMI_in_assignmentStatement1269); 
            char_literal18_tree = (CommonTree)adaptor.create(char_literal18);
            adaptor.addChild(root_0, char_literal18_tree);

             retval.statement = new AssignmentStatement(scopeStack.peekLast(), e.expression, v.ident); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "assignmentStatement"

    public static class ifStatement_return extends ParserRuleReturnScope {
        public Statement statement;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "ifStatement"
    // src/Fibitos.g:264:1: ifStatement returns [Statement statement] : 'if' LPAREN e= expression RPAREN LBRACE (ts= statement )* RBRACE ( 'else' LBRACE (fs= statement )* RBRACE )? ;
    public final FibitosParser.ifStatement_return ifStatement() throws RecognitionException {
        FibitosParser.ifStatement_return retval = new FibitosParser.ifStatement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token string_literal19=null;
        Token LPAREN20=null;
        Token RPAREN21=null;
        Token LBRACE22=null;
        Token RBRACE23=null;
        Token string_literal24=null;
        Token LBRACE25=null;
        Token RBRACE26=null;
        FibitosParser.expression_return e = null;

        FibitosParser.statement_return ts = null;

        FibitosParser.statement_return fs = null;


        CommonTree string_literal19_tree=null;
        CommonTree LPAREN20_tree=null;
        CommonTree RPAREN21_tree=null;
        CommonTree LBRACE22_tree=null;
        CommonTree RBRACE23_tree=null;
        CommonTree string_literal24_tree=null;
        CommonTree LBRACE25_tree=null;
        CommonTree RBRACE26_tree=null;

        try {
            // src/Fibitos.g:265:2: ( 'if' LPAREN e= expression RPAREN LBRACE (ts= statement )* RBRACE ( 'else' LBRACE (fs= statement )* RBRACE )? )
            // src/Fibitos.g:265:4: 'if' LPAREN e= expression RPAREN LBRACE (ts= statement )* RBRACE ( 'else' LBRACE (fs= statement )* RBRACE )?
            {
            root_0 = (CommonTree)adaptor.nil();

            string_literal19=(Token)match(input,45,FOLLOW_45_in_ifStatement1288); 
            string_literal19_tree = (CommonTree)adaptor.create(string_literal19);
            adaptor.addChild(root_0, string_literal19_tree);

            LPAREN20=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_ifStatement1290); 
            LPAREN20_tree = (CommonTree)adaptor.create(LPAREN20);
            adaptor.addChild(root_0, LPAREN20_tree);

            pushFollow(FOLLOW_expression_in_ifStatement1294);
            e=expression();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
             List<Statement> trueStatements = new LinkedList<Statement>(); 
             List<Statement> falseStatements = new LinkedList<Statement>(); 
            RPAREN21=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_ifStatement1306); 
            RPAREN21_tree = (CommonTree)adaptor.create(RPAREN21);
            adaptor.addChild(root_0, RPAREN21_tree);

            LBRACE22=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_ifStatement1308); 
            LBRACE22_tree = (CommonTree)adaptor.create(LBRACE22);
            adaptor.addChild(root_0, LBRACE22_tree);

            // src/Fibitos.g:269:4: (ts= statement )*
            loop12:
            do {
                int alt12=2;
                int LA12_0 = input.LA(1);

                if ( (LA12_0==IDENT||LA12_0==45||(LA12_0>=47 && LA12_0<=48)) ) {
                    alt12=1;
                }


                switch (alt12) {
            	case 1 :
            	    // src/Fibitos.g:269:5: ts= statement
            	    {
            	    pushFollow(FOLLOW_statement_in_ifStatement1316);
            	    ts=statement();

            	    state._fsp--;

            	    adaptor.addChild(root_0, ts.getTree());
            	     trueStatements.add((ts!=null?ts.statement:null)); 

            	    }
            	    break;

            	default :
            	    break loop12;
                }
            } while (true);

            RBRACE23=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_ifStatement1327); 
            RBRACE23_tree = (CommonTree)adaptor.create(RBRACE23);
            adaptor.addChild(root_0, RBRACE23_tree);

            // src/Fibitos.g:271:3: ( 'else' LBRACE (fs= statement )* RBRACE )?
            int alt14=2;
            int LA14_0 = input.LA(1);

            if ( (LA14_0==46) ) {
                alt14=1;
            }
            switch (alt14) {
                case 1 :
                    // src/Fibitos.g:271:4: 'else' LBRACE (fs= statement )* RBRACE
                    {
                    string_literal24=(Token)match(input,46,FOLLOW_46_in_ifStatement1332); 
                    string_literal24_tree = (CommonTree)adaptor.create(string_literal24);
                    adaptor.addChild(root_0, string_literal24_tree);

                    LBRACE25=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_ifStatement1335); 
                    LBRACE25_tree = (CommonTree)adaptor.create(LBRACE25);
                    adaptor.addChild(root_0, LBRACE25_tree);

                    // src/Fibitos.g:272:4: (fs= statement )*
                    loop13:
                    do {
                        int alt13=2;
                        int LA13_0 = input.LA(1);

                        if ( (LA13_0==IDENT||LA13_0==45||(LA13_0>=47 && LA13_0<=48)) ) {
                            alt13=1;
                        }


                        switch (alt13) {
                    	case 1 :
                    	    // src/Fibitos.g:272:5: fs= statement
                    	    {
                    	    pushFollow(FOLLOW_statement_in_ifStatement1343);
                    	    fs=statement();

                    	    state._fsp--;

                    	    adaptor.addChild(root_0, fs.getTree());
                    	     falseStatements.add((fs!=null?fs.statement:null)); 

                    	    }
                    	    break;

                    	default :
                    	    break loop13;
                        }
                    } while (true);

                    RBRACE26=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_ifStatement1353); 
                    RBRACE26_tree = (CommonTree)adaptor.create(RBRACE26);
                    adaptor.addChild(root_0, RBRACE26_tree);


                    }
                    break;

            }

             retval.statement = new IfStatement(scopeStack.peekLast(), (e!=null?e.expression:null), trueStatements, falseStatements); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "ifStatement"

    public static class whileStatement_return extends ParserRuleReturnScope {
        public Statement statement;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "whileStatement"
    // src/Fibitos.g:277:1: whileStatement returns [Statement statement] : 'while' LPAREN e= expression RPAREN LBRACE (s= statement )* RBRACE ;
    public final FibitosParser.whileStatement_return whileStatement() throws RecognitionException {
        FibitosParser.whileStatement_return retval = new FibitosParser.whileStatement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token string_literal27=null;
        Token LPAREN28=null;
        Token RPAREN29=null;
        Token LBRACE30=null;
        Token RBRACE31=null;
        FibitosParser.expression_return e = null;

        FibitosParser.statement_return s = null;


        CommonTree string_literal27_tree=null;
        CommonTree LPAREN28_tree=null;
        CommonTree RPAREN29_tree=null;
        CommonTree LBRACE30_tree=null;
        CommonTree RBRACE31_tree=null;

        try {
            // src/Fibitos.g:278:2: ( 'while' LPAREN e= expression RPAREN LBRACE (s= statement )* RBRACE )
            // src/Fibitos.g:278:4: 'while' LPAREN e= expression RPAREN LBRACE (s= statement )* RBRACE
            {
            root_0 = (CommonTree)adaptor.nil();

            string_literal27=(Token)match(input,47,FOLLOW_47_in_whileStatement1376); 
            string_literal27_tree = (CommonTree)adaptor.create(string_literal27);
            adaptor.addChild(root_0, string_literal27_tree);

            LPAREN28=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_whileStatement1378); 
            LPAREN28_tree = (CommonTree)adaptor.create(LPAREN28);
            adaptor.addChild(root_0, LPAREN28_tree);

            pushFollow(FOLLOW_expression_in_whileStatement1382);
            e=expression();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
            RPAREN29=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_whileStatement1384); 
            RPAREN29_tree = (CommonTree)adaptor.create(RPAREN29);
            adaptor.addChild(root_0, RPAREN29_tree);

            LBRACE30=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_whileStatement1389); 
            LBRACE30_tree = (CommonTree)adaptor.create(LBRACE30);
            adaptor.addChild(root_0, LBRACE30_tree);

             List<Statement> statements = new LinkedList<Statement>(); 
            // src/Fibitos.g:281:4: (s= statement )*
            loop15:
            do {
                int alt15=2;
                int LA15_0 = input.LA(1);

                if ( (LA15_0==IDENT||LA15_0==45||(LA15_0>=47 && LA15_0<=48)) ) {
                    alt15=1;
                }


                switch (alt15) {
            	case 1 :
            	    // src/Fibitos.g:281:5: s= statement
            	    {
            	    pushFollow(FOLLOW_statement_in_whileStatement1402);
            	    s=statement();

            	    state._fsp--;

            	    adaptor.addChild(root_0, s.getTree());
            	     statements.add(s.statement); 

            	    }
            	    break;

            	default :
            	    break loop15;
                }
            } while (true);

             retval.statement = new WhileStatement(scopeStack.peekLast(), (e!=null?e.expression:null), statements); 
            RBRACE31=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_whileStatement1417); 
            RBRACE31_tree = (CommonTree)adaptor.create(RBRACE31);
            adaptor.addChild(root_0, RBRACE31_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "whileStatement"

    public static class returnStatement_return extends ParserRuleReturnScope {
        public Statement statement;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "returnStatement"
    // src/Fibitos.g:286:1: returnStatement returns [Statement statement] : 'return' e= expression ;
    public final FibitosParser.returnStatement_return returnStatement() throws RecognitionException {
        FibitosParser.returnStatement_return retval = new FibitosParser.returnStatement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token string_literal32=null;
        FibitosParser.expression_return e = null;


        CommonTree string_literal32_tree=null;

        try {
            // src/Fibitos.g:287:2: ( 'return' e= expression )
            // src/Fibitos.g:287:4: 'return' e= expression
            {
            root_0 = (CommonTree)adaptor.nil();

            string_literal32=(Token)match(input,48,FOLLOW_48_in_returnStatement1432); 
            string_literal32_tree = (CommonTree)adaptor.create(string_literal32);
            adaptor.addChild(root_0, string_literal32_tree);

            pushFollow(FOLLOW_expression_in_returnStatement1436);
            e=expression();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
             retval.statement = new ReturnStatement(scopeStack.peekLast(), methodStack.peekLast(), (e!=null?e.expression:null)); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "returnStatement"

    public static class expression_return extends ParserRuleReturnScope {
        public Expression expression;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "expression"
    // src/Fibitos.g:291:1: expression returns [Expression expression] : e= conditionalOrExpression ;
    public final FibitosParser.expression_return expression() throws RecognitionException {
        FibitosParser.expression_return retval = new FibitosParser.expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        FibitosParser.conditionalOrExpression_return e = null;



        try {
            // src/Fibitos.g:292:2: (e= conditionalOrExpression )
            // src/Fibitos.g:292:4: e= conditionalOrExpression
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_conditionalOrExpression_in_expression1458);
            e=conditionalOrExpression();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
             retval.expression = e.expression; 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "expression"

    public static class conditionalOrExpression_return extends ParserRuleReturnScope {
        public Expression expression;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "conditionalOrExpression"
    // src/Fibitos.g:295:1: conditionalOrExpression returns [Expression expression] : e= conditionalAndExpression ( '||' e= conditionalAndExpression )* ;
    public final FibitosParser.conditionalOrExpression_return conditionalOrExpression() throws RecognitionException {
        FibitosParser.conditionalOrExpression_return retval = new FibitosParser.conditionalOrExpression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token string_literal33=null;
        FibitosParser.conditionalAndExpression_return e = null;


        CommonTree string_literal33_tree=null;

        try {
            // src/Fibitos.g:296:2: (e= conditionalAndExpression ( '||' e= conditionalAndExpression )* )
            // src/Fibitos.g:296:4: e= conditionalAndExpression ( '||' e= conditionalAndExpression )*
            {
            root_0 = (CommonTree)adaptor.nil();

             List<Expression> expressionList = new LinkedList<Expression>(); 
            pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression1482);
            e=conditionalAndExpression();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
             expressionList.add(e.expression); 
            // src/Fibitos.g:298:3: ( '||' e= conditionalAndExpression )*
            loop16:
            do {
                int alt16=2;
                alt16 = dfa16.predict(input);
                switch (alt16) {
            	case 1 :
            	    // src/Fibitos.g:298:5: '||' e= conditionalAndExpression
            	    {
            	    string_literal33=(Token)match(input,49,FOLLOW_49_in_conditionalOrExpression1490); 
            	    string_literal33_tree = (CommonTree)adaptor.create(string_literal33);
            	    adaptor.addChild(root_0, string_literal33_tree);

            	    pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression1494);
            	    e=conditionalAndExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, e.getTree());
            	     expressionList.add(e.expression); 

            	    }
            	    break;

            	default :
            	    break loop16;
                }
            } while (true);

             try {retval.expression = new ConditionalOrExpression(scopeStack.peekLast(), expressionList);} catch(Exception ex){/* TODO*/} 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "conditionalOrExpression"

    public static class conditionalAndExpression_return extends ParserRuleReturnScope {
        public ConditionalAndExpression expression;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "conditionalAndExpression"
    // src/Fibitos.g:302:1: conditionalAndExpression returns [ConditionalAndExpression expression] : e= equalityExpression ( '&&' e= equalityExpression )* ;
    public final FibitosParser.conditionalAndExpression_return conditionalAndExpression() throws RecognitionException {
        FibitosParser.conditionalAndExpression_return retval = new FibitosParser.conditionalAndExpression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token string_literal34=null;
        FibitosParser.equalityExpression_return e = null;


        CommonTree string_literal34_tree=null;

        try {
            // src/Fibitos.g:303:2: (e= equalityExpression ( '&&' e= equalityExpression )* )
            // src/Fibitos.g:303:4: e= equalityExpression ( '&&' e= equalityExpression )*
            {
            root_0 = (CommonTree)adaptor.nil();

             List<Expression> expressionList = new LinkedList<Expression>(); 
            pushFollow(FOLLOW_equalityExpression_in_conditionalAndExpression1525);
            e=equalityExpression();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
             expressionList.add(e.expression); 
            // src/Fibitos.g:305:3: ( '&&' e= equalityExpression )*
            loop17:
            do {
                int alt17=2;
                alt17 = dfa17.predict(input);
                switch (alt17) {
            	case 1 :
            	    // src/Fibitos.g:305:5: '&&' e= equalityExpression
            	    {
            	    string_literal34=(Token)match(input,50,FOLLOW_50_in_conditionalAndExpression1533); 
            	    string_literal34_tree = (CommonTree)adaptor.create(string_literal34);
            	    adaptor.addChild(root_0, string_literal34_tree);

            	    pushFollow(FOLLOW_equalityExpression_in_conditionalAndExpression1537);
            	    e=equalityExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, e.getTree());
            	     expressionList.add(e.expression); 

            	    }
            	    break;

            	default :
            	    break loop17;
                }
            } while (true);

             try {retval.expression = new ConditionalAndExpression(scopeStack.peekLast(), expressionList);} catch(Exception ex){/* TODO*/} 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "conditionalAndExpression"

    public static class equalityExpression_return extends ParserRuleReturnScope {
        public EqualityExpression expression;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "equalityExpression"
    // src/Fibitos.g:309:1: equalityExpression returns [EqualityExpression expression] : e= relationalExpression (o= ( '==' | '!=' ) e= relationalExpression )* ;
    public final FibitosParser.equalityExpression_return equalityExpression() throws RecognitionException {
        FibitosParser.equalityExpression_return retval = new FibitosParser.equalityExpression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token o=null;
        FibitosParser.relationalExpression_return e = null;


        CommonTree o_tree=null;

        try {
            // src/Fibitos.g:310:2: (e= relationalExpression (o= ( '==' | '!=' ) e= relationalExpression )* )
            // src/Fibitos.g:310:4: e= relationalExpression (o= ( '==' | '!=' ) e= relationalExpression )*
            {
            root_0 = (CommonTree)adaptor.nil();

             ArrayList<Expression> expressionList = new ArrayList<Expression>(); 
             ArrayList<EqualityExpression.Sign> operators = new ArrayList<EqualityExpression.Sign>(); 
            pushFollow(FOLLOW_relationalExpression_in_equalityExpression1572);
            e=relationalExpression();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
             { expressionList.add(e.expression); } 
            // src/Fibitos.g:313:3: (o= ( '==' | '!=' ) e= relationalExpression )*
            loop18:
            do {
                int alt18=2;
                alt18 = dfa18.predict(input);
                switch (alt18) {
            	case 1 :
            	    // src/Fibitos.g:313:5: o= ( '==' | '!=' ) e= relationalExpression
            	    {
            	    o=(Token)input.LT(1);
            	    if ( input.LA(1)==EQUALS||input.LA(1)==NOT_EQUALS ) {
            	        input.consume();
            	        adaptor.addChild(root_0, (CommonTree)adaptor.create(o));
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }

            	     (o!=null?o.getText():null).intern();
            	    		if((o!=null?o.getText():null).equals("=="))
            	    			operators.add(EqualityExpression.Sign.EQUAL);
            	    		else
            	    			operators.add(EqualityExpression.Sign.NOT_EQUAL);
            	    		
            	    pushFollow(FOLLOW_relationalExpression_in_equalityExpression1601);
            	    e=relationalExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, e.getTree());
            	     expressionList.add(e.expression); 

            	    }
            	    break;

            	default :
            	    break loop18;
                }
            } while (true);

             try{
            			retval.expression = new EqualityExpression(scopeStack.peekLast(), operators, expressionList); 
            		  }catch(ExpressionException exc) {}	
            		

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "equalityExpression"

    public static class relationalExpression_return extends ParserRuleReturnScope {
        public RelationalExpression expression;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "relationalExpression"
    // src/Fibitos.g:327:1: relationalExpression returns [RelationalExpression expression] : e= additiveExpression (o= relationalOp e= additiveExpression )* ;
    public final FibitosParser.relationalExpression_return relationalExpression() throws RecognitionException {
        FibitosParser.relationalExpression_return retval = new FibitosParser.relationalExpression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        FibitosParser.additiveExpression_return e = null;

        FibitosParser.relationalOp_return o = null;



        try {
            // src/Fibitos.g:328:2: (e= additiveExpression (o= relationalOp e= additiveExpression )* )
            // src/Fibitos.g:328:4: e= additiveExpression (o= relationalOp e= additiveExpression )*
            {
            root_0 = (CommonTree)adaptor.nil();

             ArrayList<Expression> expressionList = new ArrayList<Expression>(); 
             ArrayList<RelationalExpression.Sign> operators = new ArrayList<RelationalExpression.Sign>(); 
            pushFollow(FOLLOW_additiveExpression_in_relationalExpression1636);
            e=additiveExpression();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
             { expressionList.add(e.expression); } 
            // src/Fibitos.g:331:3: (o= relationalOp e= additiveExpression )*
            loop19:
            do {
                int alt19=2;
                alt19 = dfa19.predict(input);
                switch (alt19) {
            	case 1 :
            	    // src/Fibitos.g:331:5: o= relationalOp e= additiveExpression
            	    {
            	    pushFollow(FOLLOW_relationalOp_in_relationalExpression1646);
            	    o=relationalOp();

            	    state._fsp--;

            	    adaptor.addChild(root_0, o.getTree());
            	     
            	    		(o!=null?input.toString(o.start,o.stop):null).intern();
            	    		if((o!=null?input.toString(o.start,o.stop):null).equals("<"))
            	    			operators.add(RelationalExpression.Sign.LT);
            	    		else if((o!=null?input.toString(o.start,o.stop):null).equals(">"))
            	    			operators.add(RelationalExpression.Sign.GT);
            	    		else if((o!=null?input.toString(o.start,o.stop):null).equals("<="))
            	    			operators.add(RelationalExpression.Sign.LE);
            	    		else
            	    			operators.add(RelationalExpression.Sign.GE);
            	    		 
            	    pushFollow(FOLLOW_additiveExpression_in_relationalExpression1654);
            	    e=additiveExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, e.getTree());
            	     expressionList.add(e.expression); 

            	    }
            	    break;

            	default :
            	    break loop19;
                }
            } while (true);

             try{
            			retval.expression = new RelationalExpression(scopeStack.peekLast(), expressionList, operators); 
            		  }catch(ExpressionException exc) {}
            		

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "relationalExpression"

    public static class relationalOp_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "relationalOp"
    // src/Fibitos.g:350:1: relationalOp : ( '<' | '>' | '<=' | '>=' );
    public final FibitosParser.relationalOp_return relationalOp() throws RecognitionException {
        FibitosParser.relationalOp_return retval = new FibitosParser.relationalOp_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set35=null;

        CommonTree set35_tree=null;

        try {
            // src/Fibitos.g:351:2: ( '<' | '>' | '<=' | '>=' )
            // src/Fibitos.g:
            {
            root_0 = (CommonTree)adaptor.nil();

            set35=(Token)input.LT(1);
            if ( (input.LA(1)>=LTE && input.LA(1)<=GT) ) {
                input.consume();
                adaptor.addChild(root_0, (CommonTree)adaptor.create(set35));
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "relationalOp"

    public static class additiveExpression_return extends ParserRuleReturnScope {
        public AdditiveExpression expression;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "additiveExpression"
    // src/Fibitos.g:354:1: additiveExpression returns [AdditiveExpression expression] : e= multiplicativeExpression (o= ( '+' | '-' ) e= multiplicativeExpression )* ;
    public final FibitosParser.additiveExpression_return additiveExpression() throws RecognitionException {
        FibitosParser.additiveExpression_return retval = new FibitosParser.additiveExpression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token o=null;
        FibitosParser.multiplicativeExpression_return e = null;


        CommonTree o_tree=null;

        try {
            // src/Fibitos.g:355:2: (e= multiplicativeExpression (o= ( '+' | '-' ) e= multiplicativeExpression )* )
            // src/Fibitos.g:355:4: e= multiplicativeExpression (o= ( '+' | '-' ) e= multiplicativeExpression )*
            {
            root_0 = (CommonTree)adaptor.nil();

             ArrayList<Expression> expressionList = new ArrayList<Expression>(); 
             ArrayList<AdditiveExpression.Sign> operators = new ArrayList<AdditiveExpression.Sign>(); 
            pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression1717);
            e=multiplicativeExpression();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
             { expressionList.add(e.expression); } 
            // src/Fibitos.g:358:3: (o= ( '+' | '-' ) e= multiplicativeExpression )*
            loop20:
            do {
                int alt20=2;
                alt20 = dfa20.predict(input);
                switch (alt20) {
            	case 1 :
            	    // src/Fibitos.g:358:5: o= ( '+' | '-' ) e= multiplicativeExpression
            	    {
            	    o=(Token)input.LT(1);
            	    if ( (input.LA(1)>=PLUS && input.LA(1)<=MINUS) ) {
            	        input.consume();
            	        adaptor.addChild(root_0, (CommonTree)adaptor.create(o));
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    		if((o!=null?o.getText():null).equals("+"))
            	    			operators.add(AdditiveExpression.Sign.PLUS);
            	    		else
            	    			operators.add(AdditiveExpression.Sign.MINUS);
            	    		
            	    pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression1745);
            	    e=multiplicativeExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, e.getTree());
            	     { expressionList.add(e.expression); } 

            	    }
            	    break;

            	default :
            	    break loop20;
                }
            } while (true);

             try{	
            			retval.expression = new AdditiveExpression(scopeStack.peekLast(), expressionList, operators); 
            		  }catch(ExpressionException exc) {}
            		

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "additiveExpression"

    public static class multiplicativeExpression_return extends ParserRuleReturnScope {
        public MultiplicativeExpression expression;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "multiplicativeExpression"
    // src/Fibitos.g:373:1: multiplicativeExpression returns [MultiplicativeExpression expression] : e= unaryExpression (o= ( '*' | '/' ) e= unaryExpression )* ;
    public final FibitosParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException {
        FibitosParser.multiplicativeExpression_return retval = new FibitosParser.multiplicativeExpression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token o=null;
        FibitosParser.unaryExpression_return e = null;


        CommonTree o_tree=null;

        try {
            // src/Fibitos.g:374:2: (e= unaryExpression (o= ( '*' | '/' ) e= unaryExpression )* )
            // src/Fibitos.g:374:4: e= unaryExpression (o= ( '*' | '/' ) e= unaryExpression )*
            {
            root_0 = (CommonTree)adaptor.nil();

             ArrayList<Expression> expressionList = new ArrayList<Expression>(); 
             ArrayList<MultiplicativeExpression.Sign> operators = new ArrayList<MultiplicativeExpression.Sign>(); 
            pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression1783);
            e=unaryExpression();

            state._fsp--;

            adaptor.addChild(root_0, e.getTree());
             { expressionList.add(e.expression); } 
            // src/Fibitos.g:377:3: (o= ( '*' | '/' ) e= unaryExpression )*
            loop21:
            do {
                int alt21=2;
                alt21 = dfa21.predict(input);
                switch (alt21) {
            	case 1 :
            	    // src/Fibitos.g:377:5: o= ( '*' | '/' ) e= unaryExpression
            	    {
            	    o=(Token)input.LT(1);
            	    if ( (input.LA(1)>=TIMES && input.LA(1)<=DIV) ) {
            	        input.consume();
            	        adaptor.addChild(root_0, (CommonTree)adaptor.create(o));
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    		if((o!=null?o.getText():null).equals("*"))
            	    			operators.add(MultiplicativeExpression.Sign.MULTIPLICATION);
            	    		else
            	    			operators.add(MultiplicativeExpression.Sign.DIVISION);
            	    		
            	    pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression1811);
            	    e=unaryExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, e.getTree());
            	     { expressionList.add(e.expression); } 

            	    }
            	    break;

            	default :
            	    break loop21;
                }
            } while (true);

              try{	
            			retval.expression = new MultiplicativeExpression(scopeStack.peekLast(), expressionList, operators); 
            		  }catch(ExpressionException exc) {  } 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "multiplicativeExpression"

    public static class unaryExpression_return extends ParserRuleReturnScope {
        public UnaryExpression expression;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "unaryExpression"
    // src/Fibitos.g:391:1: unaryExpression returns [UnaryExpression expression] : ( '+' e= unaryExpression | '-' e= unaryExpression | ue= negationExpression ) ;
    public final FibitosParser.unaryExpression_return unaryExpression() throws RecognitionException {
        FibitosParser.unaryExpression_return retval = new FibitosParser.unaryExpression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal36=null;
        Token char_literal37=null;
        FibitosParser.unaryExpression_return e = null;

        FibitosParser.negationExpression_return ue = null;


        CommonTree char_literal36_tree=null;
        CommonTree char_literal37_tree=null;

        try {
            // src/Fibitos.g:392:2: ( ( '+' e= unaryExpression | '-' e= unaryExpression | ue= negationExpression ) )
            // src/Fibitos.g:392:4: ( '+' e= unaryExpression | '-' e= unaryExpression | ue= negationExpression )
            {
            root_0 = (CommonTree)adaptor.nil();

             UnaryExpression.Sign oper = null; Expression expr = null;
            // src/Fibitos.g:393:2: ( '+' e= unaryExpression | '-' e= unaryExpression | ue= negationExpression )
            int alt22=3;
            alt22 = dfa22.predict(input);
            switch (alt22) {
                case 1 :
                    // src/Fibitos.g:394:3: '+' e= unaryExpression
                    {
                    char_literal36=(Token)match(input,PLUS,FOLLOW_PLUS_in_unaryExpression1845); 
                    char_literal36_tree = (CommonTree)adaptor.create(char_literal36);
                    adaptor.addChild(root_0, char_literal36_tree);

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression1849);
                    e=unaryExpression();

                    state._fsp--;

                    adaptor.addChild(root_0, e.getTree());
                     oper = UnaryExpression.Sign.PLUS; expr = e.expression;

                    }
                    break;
                case 2 :
                    // src/Fibitos.g:396:4: '-' e= unaryExpression
                    {
                    char_literal37=(Token)match(input,MINUS,FOLLOW_MINUS_in_unaryExpression1859); 
                    char_literal37_tree = (CommonTree)adaptor.create(char_literal37);
                    adaptor.addChild(root_0, char_literal37_tree);

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression1863);
                    e=unaryExpression();

                    state._fsp--;

                    adaptor.addChild(root_0, e.getTree());
                     oper = UnaryExpression.Sign.MINUS; expr = e.expression;

                    }
                    break;
                case 3 :
                    // src/Fibitos.g:398:4: ue= negationExpression
                    {
                    pushFollow(FOLLOW_negationExpression_in_unaryExpression1875);
                    ue=negationExpression();

                    state._fsp--;

                    adaptor.addChild(root_0, ue.getTree());
                     oper = UnaryExpression.Sign.NONE; expr = ue.expression;

                    }
                    break;

            }


            		try{
            			retval.expression = new UnaryExpression(scopeStack.peekLast(), expr, oper);
            		}catch(ExpressionException exc) {}
            		

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "unaryExpression"

    public static class negationExpression_return extends ParserRuleReturnScope {
        public NegationExpression expression;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "negationExpression"
    // src/Fibitos.g:408:1: negationExpression returns [NegationExpression expression] : ( '!' e= negationExpression | p= primary ) ;
    public final FibitosParser.negationExpression_return negationExpression() throws RecognitionException {
        FibitosParser.negationExpression_return retval = new FibitosParser.negationExpression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal38=null;
        FibitosParser.negationExpression_return e = null;

        FibitosParser.primary_return p = null;


        CommonTree char_literal38_tree=null;

        try {
            // src/Fibitos.g:409:2: ( ( '!' e= negationExpression | p= primary ) )
            // src/Fibitos.g:409:4: ( '!' e= negationExpression | p= primary )
            {
            root_0 = (CommonTree)adaptor.nil();

             NegationExpression.Sign sign = null; Expression expr = null; 
            // src/Fibitos.g:410:2: ( '!' e= negationExpression | p= primary )
            int alt23=2;
            alt23 = dfa23.predict(input);
            switch (alt23) {
                case 1 :
                    // src/Fibitos.g:411:3: '!' e= negationExpression
                    {
                    char_literal38=(Token)match(input,51,FOLLOW_51_in_negationExpression1909); 
                    char_literal38_tree = (CommonTree)adaptor.create(char_literal38);
                    adaptor.addChild(root_0, char_literal38_tree);

                    pushFollow(FOLLOW_negationExpression_in_negationExpression1913);
                    e=negationExpression();

                    state._fsp--;

                    adaptor.addChild(root_0, e.getTree());
                     sign = NegationExpression.Sign.NOT; expr = e.expression; 

                    }
                    break;
                case 2 :
                    // src/Fibitos.g:412:4: p= primary
                    {
                    pushFollow(FOLLOW_primary_in_negationExpression1922);
                    p=primary();

                    state._fsp--;

                    adaptor.addChild(root_0, p.getTree());
                     sign = NegationExpression.Sign.NONE; expr = p.expression; 

                    }
                    break;

            }

             
            		try{
            			retval.expression = new NegationExpression(scopeStack.peekLast(), expr, sign);
            		}catch(ExpressionException exc) { }
            		

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "negationExpression"

    public static class primary_return extends ParserRuleReturnScope {
        public PrimaryExpression expression;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "primary"
    // src/Fibitos.g:423:1: primary returns [PrimaryExpression expression] : ( LPAREN e= expression RPAREN | lit= literal | s= symbol | 'new' c= creator ) ;
    public final FibitosParser.primary_return primary() throws RecognitionException {
        FibitosParser.primary_return retval = new FibitosParser.primary_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token LPAREN39=null;
        Token RPAREN40=null;
        Token string_literal41=null;
        FibitosParser.expression_return e = null;

        FibitosParser.literal_return lit = null;

        FibitosParser.symbol_return s = null;

        FibitosParser.creator_return c = null;


        CommonTree LPAREN39_tree=null;
        CommonTree RPAREN40_tree=null;
        CommonTree string_literal41_tree=null;

        try {
            // src/Fibitos.g:424:2: ( ( LPAREN e= expression RPAREN | lit= literal | s= symbol | 'new' c= creator ) )
            // src/Fibitos.g:424:4: ( LPAREN e= expression RPAREN | lit= literal | s= symbol | 'new' c= creator )
            {
            root_0 = (CommonTree)adaptor.nil();

             Expression expr = null; PrimaryExpression.PrimaryType type = null;
            // src/Fibitos.g:425:2: ( LPAREN e= expression RPAREN | lit= literal | s= symbol | 'new' c= creator )
            int alt24=4;
            switch ( input.LA(1) ) {
            case LPAREN:
                {
                alt24=1;
                }
                break;
            case INTLIT:
            case DOUBLELIT:
            case CHARLIT:
            case STRINGLIT:
            case 53:
            case 54:
                {
                alt24=2;
                }
                break;
            case IDENT:
                {
                alt24=3;
                }
                break;
            case 52:
                {
                alt24=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 24, 0, input);

                throw nvae;
            }

            switch (alt24) {
                case 1 :
                    // src/Fibitos.g:425:4: LPAREN e= expression RPAREN
                    {
                    LPAREN39=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_primary1955); 
                    LPAREN39_tree = (CommonTree)adaptor.create(LPAREN39);
                    adaptor.addChild(root_0, LPAREN39_tree);

                    pushFollow(FOLLOW_expression_in_primary1959);
                    e=expression();

                    state._fsp--;

                    adaptor.addChild(root_0, e.getTree());
                    RPAREN40=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_primary1961); 
                    RPAREN40_tree = (CommonTree)adaptor.create(RPAREN40);
                    adaptor.addChild(root_0, RPAREN40_tree);

                     expr = (e!=null?e.expression:null); type = PrimaryExpression.PrimaryType.expression; 

                    }
                    break;
                case 2 :
                    // src/Fibitos.g:426:4: lit= literal
                    {
                    pushFollow(FOLLOW_literal_in_primary1970);
                    lit=literal();

                    state._fsp--;

                    adaptor.addChild(root_0, lit.getTree());
                     expr = (lit!=null?lit.literal:null); type = PrimaryExpression.PrimaryType.literal; 

                    }
                    break;
                case 3 :
                    // src/Fibitos.g:427:4: s= symbol
                    {
                    pushFollow(FOLLOW_symbol_in_primary1979);
                    s=symbol();

                    state._fsp--;

                    adaptor.addChild(root_0, s.getTree());
                     expr = (s!=null?s.ident:null); type = PrimaryExpression.PrimaryType.symbol; 

                    }
                    break;
                case 4 :
                    // src/Fibitos.g:428:4: 'new' c= creator
                    {
                    string_literal41=(Token)match(input,52,FOLLOW_52_in_primary1986); 
                    string_literal41_tree = (CommonTree)adaptor.create(string_literal41);
                    adaptor.addChild(root_0, string_literal41_tree);

                    pushFollow(FOLLOW_creator_in_primary1990);
                    c=creator();

                    state._fsp--;

                    adaptor.addChild(root_0, c.getTree());
                     expr = (c!=null?c.creator:null); type = PrimaryExpression.PrimaryType.creator; 

                    }
                    break;

            }

             try{
            			retval.expression = new PrimaryExpression(scopeStack.peekLast(), expr, type); 
            		  }catch(Exception exc) {}
            		

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "primary"

    public static class creator_return extends ParserRuleReturnScope {
        public Creator creator;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "creator"
    // src/Fibitos.g:435:1: creator returns [Creator creator] : id= CLASS_IDENT LPAREN RPAREN ;
    public final FibitosParser.creator_return creator() throws RecognitionException {
        FibitosParser.creator_return retval = new FibitosParser.creator_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token id=null;
        Token LPAREN42=null;
        Token RPAREN43=null;

        CommonTree id_tree=null;
        CommonTree LPAREN42_tree=null;
        CommonTree RPAREN43_tree=null;

        try {
            // src/Fibitos.g:436:2: (id= CLASS_IDENT LPAREN RPAREN )
            // src/Fibitos.g:436:4: id= CLASS_IDENT LPAREN RPAREN
            {
            root_0 = (CommonTree)adaptor.nil();

             List<Expression> args = new LinkedList<Expression>(); 
            id=(Token)match(input,CLASS_IDENT,FOLLOW_CLASS_IDENT_in_creator2020); 
            id_tree = (CommonTree)adaptor.create(id);
            adaptor.addChild(root_0, id_tree);

            LPAREN42=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_creator2022); 
            LPAREN42_tree = (CommonTree)adaptor.create(LPAREN42);
            adaptor.addChild(root_0, LPAREN42_tree);

            RPAREN43=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_creator2024); 
            RPAREN43_tree = (CommonTree)adaptor.create(RPAREN43);
            adaptor.addChild(root_0, RPAREN43_tree);

            retval.creator = new Creator(scopeStack.peekLast(), (id!=null?id.getText():null)); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "creator"

    public static class literal_return extends ParserRuleReturnScope {
        public Literal literal;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "literal"
    // src/Fibitos.g:441:1: literal returns [Literal literal] : ( INTLIT | DOUBLELIT | CHARLIT | STRINGLIT | boollit ) ;
    public final FibitosParser.literal_return literal() throws RecognitionException {
        FibitosParser.literal_return retval = new FibitosParser.literal_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token INTLIT44=null;
        Token DOUBLELIT45=null;
        Token CHARLIT46=null;
        Token STRINGLIT47=null;
        FibitosParser.boollit_return boollit48 = null;


        CommonTree INTLIT44_tree=null;
        CommonTree DOUBLELIT45_tree=null;
        CommonTree CHARLIT46_tree=null;
        CommonTree STRINGLIT47_tree=null;

        try {
            // src/Fibitos.g:442:5: ( ( INTLIT | DOUBLELIT | CHARLIT | STRINGLIT | boollit ) )
            // src/Fibitos.g:442:9: ( INTLIT | DOUBLELIT | CHARLIT | STRINGLIT | boollit )
            {
            root_0 = (CommonTree)adaptor.nil();

             Object val = null; String type = null;
            // src/Fibitos.g:443:6: ( INTLIT | DOUBLELIT | CHARLIT | STRINGLIT | boollit )
            int alt25=5;
            switch ( input.LA(1) ) {
            case INTLIT:
                {
                alt25=1;
                }
                break;
            case DOUBLELIT:
                {
                alt25=2;
                }
                break;
            case CHARLIT:
                {
                alt25=3;
                }
                break;
            case STRINGLIT:
                {
                alt25=4;
                }
                break;
            case 53:
            case 54:
                {
                alt25=5;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 25, 0, input);

                throw nvae;
            }

            switch (alt25) {
                case 1 :
                    // src/Fibitos.g:443:7: INTLIT
                    {
                    INTLIT44=(Token)match(input,INTLIT,FOLLOW_INTLIT_in_literal2057); 
                    INTLIT44_tree = (CommonTree)adaptor.create(INTLIT44);
                    adaptor.addChild(root_0, INTLIT44_tree);

                     val = new Integer((INTLIT44!=null?INTLIT44.getText():null)); type = "int";

                    }
                    break;
                case 2 :
                    // src/Fibitos.g:444:9: DOUBLELIT
                    {
                    DOUBLELIT45=(Token)match(input,DOUBLELIT,FOLLOW_DOUBLELIT_in_literal2069); 
                    DOUBLELIT45_tree = (CommonTree)adaptor.create(DOUBLELIT45);
                    adaptor.addChild(root_0, DOUBLELIT45_tree);

                     val = new Double((DOUBLELIT45!=null?DOUBLELIT45.getText():null)); type = "double";

                    }
                    break;
                case 3 :
                    // src/Fibitos.g:445:9: CHARLIT
                    {
                    CHARLIT46=(Token)match(input,CHARLIT,FOLLOW_CHARLIT_in_literal2081); 
                    CHARLIT46_tree = (CommonTree)adaptor.create(CHARLIT46);
                    adaptor.addChild(root_0, CHARLIT46_tree);

                     val = new Character((CHARLIT46!=null?CHARLIT46.getText():null).charAt(1)); type = "char";

                    }
                    break;
                case 4 :
                    // src/Fibitos.g:446:9: STRINGLIT
                    {
                    STRINGLIT47=(Token)match(input,STRINGLIT,FOLLOW_STRINGLIT_in_literal2093); 
                    STRINGLIT47_tree = (CommonTree)adaptor.create(STRINGLIT47);
                    adaptor.addChild(root_0, STRINGLIT47_tree);

                     val = (STRINGLIT47!=null?STRINGLIT47.getText():null).substring(1,(STRINGLIT47!=null?STRINGLIT47.getText():null).length()-1); type = "string";

                    }
                    break;
                case 5 :
                    // src/Fibitos.g:447:9: boollit
                    {
                    pushFollow(FOLLOW_boollit_in_literal2105);
                    boollit48=boollit();

                    state._fsp--;

                    adaptor.addChild(root_0, boollit48.getTree());
                     val = new Boolean((boollit48!=null?input.toString(boollit48.start,boollit48.stop):null)); type = "bool";

                    }
                    break;

            }

             retval.literal = new Literal(scopeStack.peekLast(), type, val); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "literal"

    public static class boollit_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "boollit"
    // src/Fibitos.g:452:1: boollit : ( 'true' | 'false' );
    public final FibitosParser.boollit_return boollit() throws RecognitionException {
        FibitosParser.boollit_return retval = new FibitosParser.boollit_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set49=null;

        CommonTree set49_tree=null;

        try {
            // src/Fibitos.g:452:9: ( 'true' | 'false' )
            // src/Fibitos.g:
            {
            root_0 = (CommonTree)adaptor.nil();

            set49=(Token)input.LT(1);
            if ( (input.LA(1)>=53 && input.LA(1)<=54) ) {
                input.consume();
                adaptor.addChild(root_0, (CommonTree)adaptor.create(set49));
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "boollit"

    public static class symbol_return extends ParserRuleReturnScope {
        public Ident ident;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "symbol"
    // src/Fibitos.g:454:1: symbol returns [Ident ident] : ( variable | methodCall );
    public final FibitosParser.symbol_return symbol() throws RecognitionException {
        FibitosParser.symbol_return retval = new FibitosParser.symbol_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        FibitosParser.variable_return variable50 = null;

        FibitosParser.methodCall_return methodCall51 = null;



        try {
            // src/Fibitos.g:455:2: ( variable | methodCall )
            int alt26=2;
            alt26 = dfa26.predict(input);
            switch (alt26) {
                case 1 :
                    // src/Fibitos.g:455:4: variable
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_variable_in_symbol2150);
                    variable50=variable();

                    state._fsp--;

                    adaptor.addChild(root_0, variable50.getTree());
                     retval.ident = (variable50!=null?variable50.ident:null); 

                    }
                    break;
                case 2 :
                    // src/Fibitos.g:456:4: methodCall
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_methodCall_in_symbol2157);
                    methodCall51=methodCall();

                    state._fsp--;

                    adaptor.addChild(root_0, methodCall51.getTree());
                     retval.ident = (methodCall51!=null?methodCall51.ident:null); 

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "symbol"

    public static class methodCall_return extends ParserRuleReturnScope {
        public Ident ident;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "methodCall"
    // src/Fibitos.g:459:1: methodCall returns [Ident ident] : IDENT m= callArgs ( selector )* ;
    public final FibitosParser.methodCall_return methodCall() throws RecognitionException {
        FibitosParser.methodCall_return retval = new FibitosParser.methodCall_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token IDENT52=null;
        FibitosParser.callArgs_return m = null;

        FibitosParser.selector_return selector53 = null;


        CommonTree IDENT52_tree=null;

        try {
            // src/Fibitos.g:460:2: ( IDENT m= callArgs ( selector )* )
            // src/Fibitos.g:460:4: IDENT m= callArgs ( selector )*
            {
            root_0 = (CommonTree)adaptor.nil();

             List<Selector> selectors = new LinkedList<Selector>(); 
            IDENT52=(Token)match(input,IDENT,FOLLOW_IDENT_in_methodCall2178); 
            IDENT52_tree = (CommonTree)adaptor.create(IDENT52);
            adaptor.addChild(root_0, IDENT52_tree);

            pushFollow(FOLLOW_callArgs_in_methodCall2182);
            m=callArgs();

            state._fsp--;

            adaptor.addChild(root_0, m.getTree());
             selectors.add(new Selector("call", new MethodCall((m!=null?m.expressions:null), (IDENT52!=null?IDENT52.getText():null)))); 
            // src/Fibitos.g:462:3: ( selector )*
            loop27:
            do {
                int alt27=2;
                alt27 = dfa27.predict(input);
                switch (alt27) {
            	case 1 :
            	    // src/Fibitos.g:462:4: selector
            	    {
            	    pushFollow(FOLLOW_selector_in_methodCall2190);
            	    selector53=selector();

            	    state._fsp--;

            	    adaptor.addChild(root_0, selector53.getTree());
            	     selectors.add((selector53!=null?selector53.selector:null)); 

            	    }
            	    break;

            	default :
            	    break loop27;
                }
            } while (true);

             retval.ident = new Ident(scopeStack.peekLast(), (IDENT52!=null?IDENT52.getText():null), selectors); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "methodCall"

    public static class variable_return extends ParserRuleReturnScope {
        public Ident ident;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "variable"
    // src/Fibitos.g:466:1: variable returns [Ident ident] : IDENT ( selector )* ;
    public final FibitosParser.variable_return variable() throws RecognitionException {
        FibitosParser.variable_return retval = new FibitosParser.variable_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token IDENT54=null;
        FibitosParser.selector_return selector55 = null;


        CommonTree IDENT54_tree=null;

        try {
            // src/Fibitos.g:467:2: ( IDENT ( selector )* )
            // src/Fibitos.g:467:4: IDENT ( selector )*
            {
            root_0 = (CommonTree)adaptor.nil();

             List<Selector> selectors = new LinkedList<Selector>(); 
            IDENT54=(Token)match(input,IDENT,FOLLOW_IDENT_in_variable2218); 
            IDENT54_tree = (CommonTree)adaptor.create(IDENT54);
            adaptor.addChild(root_0, IDENT54_tree);

            // src/Fibitos.g:468:9: ( selector )*
            loop28:
            do {
                int alt28=2;
                alt28 = dfa28.predict(input);
                switch (alt28) {
            	case 1 :
            	    // src/Fibitos.g:468:10: selector
            	    {
            	    pushFollow(FOLLOW_selector_in_variable2221);
            	    selector55=selector();

            	    state._fsp--;

            	    adaptor.addChild(root_0, selector55.getTree());
            	     selectors.add((selector55!=null?selector55.selector:null)); 

            	    }
            	    break;

            	default :
            	    break loop28;
                }
            } while (true);

             retval.ident = new Ident(scopeStack.peekLast(), (IDENT54!=null?IDENT54.getText():null), selectors); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "variable"

    public static class selector_return extends ParserRuleReturnScope {
        public Selector selector;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "selector"
    // src/Fibitos.g:472:1: selector returns [Selector selector] : ( LBRACKET INTLIT RBRACKET | '.' IDENT ( callArgs )? );
    public final FibitosParser.selector_return selector() throws RecognitionException {
        FibitosParser.selector_return retval = new FibitosParser.selector_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token LBRACKET56=null;
        Token INTLIT57=null;
        Token RBRACKET58=null;
        Token char_literal59=null;
        Token IDENT60=null;
        FibitosParser.callArgs_return callArgs61 = null;


        CommonTree LBRACKET56_tree=null;
        CommonTree INTLIT57_tree=null;
        CommonTree RBRACKET58_tree=null;
        CommonTree char_literal59_tree=null;
        CommonTree IDENT60_tree=null;

        try {
            // src/Fibitos.g:473:2: ( LBRACKET INTLIT RBRACKET | '.' IDENT ( callArgs )? )
            int alt30=2;
            int LA30_0 = input.LA(1);

            if ( (LA30_0==LBRACKET) ) {
                alt30=1;
            }
            else if ( (LA30_0==DOT) ) {
                alt30=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 30, 0, input);

                throw nvae;
            }
            switch (alt30) {
                case 1 :
                    // src/Fibitos.g:473:4: LBRACKET INTLIT RBRACKET
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    LBRACKET56=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_selector2245); 
                    LBRACKET56_tree = (CommonTree)adaptor.create(LBRACKET56);
                    adaptor.addChild(root_0, LBRACKET56_tree);

                    INTLIT57=(Token)match(input,INTLIT,FOLLOW_INTLIT_in_selector2247); 
                    INTLIT57_tree = (CommonTree)adaptor.create(INTLIT57);
                    adaptor.addChild(root_0, INTLIT57_tree);

                    RBRACKET58=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_selector2249); 
                    RBRACKET58_tree = (CommonTree)adaptor.create(RBRACKET58);
                    adaptor.addChild(root_0, RBRACKET58_tree);

                     retval.selector = new Selector("index", Integer.parseInt((INTLIT57!=null?INTLIT57.getText():null)) ); 

                    }
                    break;
                case 2 :
                    // src/Fibitos.g:474:4: '.' IDENT ( callArgs )?
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    char_literal59=(Token)match(input,DOT,FOLLOW_DOT_in_selector2256); 
                    char_literal59_tree = (CommonTree)adaptor.create(char_literal59);
                    adaptor.addChild(root_0, char_literal59_tree);

                    IDENT60=(Token)match(input,IDENT,FOLLOW_IDENT_in_selector2258); 
                    IDENT60_tree = (CommonTree)adaptor.create(IDENT60);
                    adaptor.addChild(root_0, IDENT60_tree);

                     String type = "attribute"; Object value = (IDENT60!=null?IDENT60.getText():null); 
                    // src/Fibitos.g:475:3: ( callArgs )?
                    int alt29=2;
                    alt29 = dfa29.predict(input);
                    switch (alt29) {
                        case 1 :
                            // src/Fibitos.g:475:4: callArgs
                            {
                            pushFollow(FOLLOW_callArgs_in_selector2265);
                            callArgs61=callArgs();

                            state._fsp--;

                            adaptor.addChild(root_0, callArgs61.getTree());
                             type = "call"; value = new MethodCall((callArgs61!=null?callArgs61.expressions:null), (IDENT60!=null?IDENT60.getText():null)); 

                            }
                            break;

                    }

                     retval.selector = new Selector(type, value); 

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "selector"

    public static class callArgs_return extends ParserRuleReturnScope {
        public List<Expression> expressions;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "callArgs"
    // src/Fibitos.g:479:1: callArgs returns [List<Expression> expressions] : LPAREN ( expressionList )? RPAREN ;
    public final FibitosParser.callArgs_return callArgs() throws RecognitionException {
        FibitosParser.callArgs_return retval = new FibitosParser.callArgs_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token LPAREN62=null;
        Token RPAREN64=null;
        FibitosParser.expressionList_return expressionList63 = null;


        CommonTree LPAREN62_tree=null;
        CommonTree RPAREN64_tree=null;

        try {
            // src/Fibitos.g:480:2: ( LPAREN ( expressionList )? RPAREN )
            // src/Fibitos.g:480:4: LPAREN ( expressionList )? RPAREN
            {
            root_0 = (CommonTree)adaptor.nil();

             retval.expressions = new LinkedList<Expression>(); 
            LPAREN62=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_callArgs2294); 
            LPAREN62_tree = (CommonTree)adaptor.create(LPAREN62);
            adaptor.addChild(root_0, LPAREN62_tree);

            // src/Fibitos.g:481:10: ( expressionList )?
            int alt31=2;
            alt31 = dfa31.predict(input);
            switch (alt31) {
                case 1 :
                    // src/Fibitos.g:481:11: expressionList
                    {
                    pushFollow(FOLLOW_expressionList_in_callArgs2297);
                    expressionList63=expressionList();

                    state._fsp--;

                    adaptor.addChild(root_0, expressionList63.getTree());
                     retval.expressions = (expressionList63!=null?expressionList63.expressions:null); 

                    }
                    break;

            }

            RPAREN64=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_callArgs2304); 
            RPAREN64_tree = (CommonTree)adaptor.create(RPAREN64);
            adaptor.addChild(root_0, RPAREN64_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "callArgs"

    public static class expressionList_return extends ParserRuleReturnScope {
        public List<Expression> expressions;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "expressionList"
    // src/Fibitos.g:485:1: expressionList returns [List<Expression> expressions] : e1= expression ( ',' e2= expression )* ;
    public final FibitosParser.expressionList_return expressionList() throws RecognitionException {
        FibitosParser.expressionList_return retval = new FibitosParser.expressionList_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal65=null;
        FibitosParser.expression_return e1 = null;

        FibitosParser.expression_return e2 = null;


        CommonTree char_literal65_tree=null;

        try {
            // src/Fibitos.g:486:2: (e1= expression ( ',' e2= expression )* )
            // src/Fibitos.g:486:4: e1= expression ( ',' e2= expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

             retval.expressions = new LinkedList<Expression>(); 
            pushFollow(FOLLOW_expression_in_expressionList2329);
            e1=expression();

            state._fsp--;

            adaptor.addChild(root_0, e1.getTree());
             retval.expressions.add(e1.expression); 
            // src/Fibitos.g:488:3: ( ',' e2= expression )*
            loop32:
            do {
                int alt32=2;
                int LA32_0 = input.LA(1);

                if ( (LA32_0==COMMA) ) {
                    alt32=1;
                }


                switch (alt32) {
            	case 1 :
            	    // src/Fibitos.g:488:5: ',' e2= expression
            	    {
            	    char_literal65=(Token)match(input,COMMA,FOLLOW_COMMA_in_expressionList2337); 
            	    char_literal65_tree = (CommonTree)adaptor.create(char_literal65);
            	    adaptor.addChild(root_0, char_literal65_tree);

            	    pushFollow(FOLLOW_expression_in_expressionList2341);
            	    e2=expression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, e2.getTree());
            	     retval.expressions.add(e2.expression); 

            	    }
            	    break;

            	default :
            	    break loop32;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "expressionList"

    // Delegated rules


    protected DFA2 dfa2 = new DFA2(this);
    protected DFA16 dfa16 = new DFA16(this);
    protected DFA17 dfa17 = new DFA17(this);
    protected DFA18 dfa18 = new DFA18(this);
    protected DFA19 dfa19 = new DFA19(this);
    protected DFA20 dfa20 = new DFA20(this);
    protected DFA21 dfa21 = new DFA21(this);
    protected DFA22 dfa22 = new DFA22(this);
    protected DFA23 dfa23 = new DFA23(this);
    protected DFA26 dfa26 = new DFA26(this);
    protected DFA27 dfa27 = new DFA27(this);
    protected DFA28 dfa28 = new DFA28(this);
    protected DFA29 dfa29 = new DFA29(this);
    protected DFA31 dfa31 = new DFA31(this);
    static final String DFA2_eotS =
        "\14\uffff";
    static final String DFA2_eofS =
        "\14\uffff";
    static final String DFA2_minS =
        "\1\16\1\17\1\uffff\1\10\1\23\1\27\2\uffff\1\17\1\23\2\uffff";
    static final String DFA2_maxS =
        "\1\54\1\26\1\uffff\1\10\1\33\1\27\2\uffff\1\17\1\33\2\uffff";
    static final String DFA2_acceptS =
        "\2\uffff\1\2\4\uffff\1\1\4\uffff";
    static final String DFA2_specialS =
        "\14\uffff}>";
    static final String[] DFA2_transitionS = {
            "\1\1\12\uffff\1\2\16\uffff\5\1",
            "\1\4\6\uffff\1\3",
            "",
            "\1\5",
            "\1\7\7\uffff\1\2",
            "\1\10",
            "",
            "",
            "\1\11",
            "\1\7\7\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS);
    static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS);
    static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS);
    static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS);
    static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS);
    static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS);
    static final short[][] DFA2_transition;

    static {
        int numStates = DFA2_transitionS.length;
        DFA2_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]);
        }
    }

    class DFA2 extends DFA {

        public DFA2(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 2;
            this.eot = DFA2_eot;
            this.eof = DFA2_eof;
            this.min = DFA2_min;
            this.max = DFA2_max;
            this.accept = DFA2_accept;
            this.special = DFA2_special;
            this.transition = DFA2_transition;
        }
        public String getDescription() {
            return "()* loopback of 188:4: (attr= attribute_declaration )*";
        }
    }
    static final String DFA16_eotS =
        "\13\uffff";
    static final String DFA16_eofS =
        "\1\1\12\uffff";
    static final String DFA16_minS =
        "\1\17\12\uffff";
    static final String DFA16_maxS =
        "\1\61\12\uffff";
    static final String DFA16_acceptS =
        "\1\uffff\1\2\10\uffff\1\1";
    static final String DFA16_specialS =
        "\13\uffff}>";
    static final String[] DFA16_transitionS = {
            "\1\1\3\uffff\2\1\4\uffff\1\1\2\uffff\1\1\20\uffff\1\1\1\uffff"+
            "\2\1\1\12",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA16_eot = DFA.unpackEncodedString(DFA16_eotS);
    static final short[] DFA16_eof = DFA.unpackEncodedString(DFA16_eofS);
    static final char[] DFA16_min = DFA.unpackEncodedStringToUnsignedChars(DFA16_minS);
    static final char[] DFA16_max = DFA.unpackEncodedStringToUnsignedChars(DFA16_maxS);
    static final short[] DFA16_accept = DFA.unpackEncodedString(DFA16_acceptS);
    static final short[] DFA16_special = DFA.unpackEncodedString(DFA16_specialS);
    static final short[][] DFA16_transition;

    static {
        int numStates = DFA16_transitionS.length;
        DFA16_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA16_transition[i] = DFA.unpackEncodedString(DFA16_transitionS[i]);
        }
    }

    class DFA16 extends DFA {

        public DFA16(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 16;
            this.eot = DFA16_eot;
            this.eof = DFA16_eof;
            this.min = DFA16_min;
            this.max = DFA16_max;
            this.accept = DFA16_accept;
            this.special = DFA16_special;
            this.transition = DFA16_transition;
        }
        public String getDescription() {
            return "()* loopback of 298:3: ( '||' e= conditionalAndExpression )*";
        }
    }
    static final String DFA17_eotS =
        "\14\uffff";
    static final String DFA17_eofS =
        "\1\1\13\uffff";
    static final String DFA17_minS =
        "\1\17\13\uffff";
    static final String DFA17_maxS =
        "\1\62\13\uffff";
    static final String DFA17_acceptS =
        "\1\uffff\1\2\11\uffff\1\1";
    static final String DFA17_specialS =
        "\14\uffff}>";
    static final String[] DFA17_transitionS = {
            "\1\1\3\uffff\2\1\4\uffff\1\1\2\uffff\1\1\20\uffff\1\1\1\uffff"+
            "\3\1\1\13",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA17_eot = DFA.unpackEncodedString(DFA17_eotS);
    static final short[] DFA17_eof = DFA.unpackEncodedString(DFA17_eofS);
    static final char[] DFA17_min = DFA.unpackEncodedStringToUnsignedChars(DFA17_minS);
    static final char[] DFA17_max = DFA.unpackEncodedStringToUnsignedChars(DFA17_maxS);
    static final short[] DFA17_accept = DFA.unpackEncodedString(DFA17_acceptS);
    static final short[] DFA17_special = DFA.unpackEncodedString(DFA17_specialS);
    static final short[][] DFA17_transition;

    static {
        int numStates = DFA17_transitionS.length;
        DFA17_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA17_transition[i] = DFA.unpackEncodedString(DFA17_transitionS[i]);
        }
    }

    class DFA17 extends DFA {

        public DFA17(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 17;
            this.eot = DFA17_eot;
            this.eof = DFA17_eof;
            this.min = DFA17_min;
            this.max = DFA17_max;
            this.accept = DFA17_accept;
            this.special = DFA17_special;
            this.transition = DFA17_transition;
        }
        public String getDescription() {
            return "()* loopback of 305:3: ( '&&' e= equalityExpression )*";
        }
    }
    static final String DFA18_eotS =
        "\15\uffff";
    static final String DFA18_eofS =
        "\1\1\14\uffff";
    static final String DFA18_minS =
        "\1\17\14\uffff";
    static final String DFA18_maxS =
        "\1\62\14\uffff";
    static final String DFA18_acceptS =
        "\1\uffff\1\2\12\uffff\1\1";
    static final String DFA18_specialS =
        "\15\uffff}>";
    static final String[] DFA18_transitionS = {
            "\1\1\3\uffff\2\1\1\14\3\uffff\1\1\2\uffff\1\1\1\14\17\uffff"+
            "\1\1\1\uffff\4\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA18_eot = DFA.unpackEncodedString(DFA18_eotS);
    static final short[] DFA18_eof = DFA.unpackEncodedString(DFA18_eofS);
    static final char[] DFA18_min = DFA.unpackEncodedStringToUnsignedChars(DFA18_minS);
    static final char[] DFA18_max = DFA.unpackEncodedStringToUnsignedChars(DFA18_maxS);
    static final short[] DFA18_accept = DFA.unpackEncodedString(DFA18_acceptS);
    static final short[] DFA18_special = DFA.unpackEncodedString(DFA18_specialS);
    static final short[][] DFA18_transition;

    static {
        int numStates = DFA18_transitionS.length;
        DFA18_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA18_transition[i] = DFA.unpackEncodedString(DFA18_transitionS[i]);
        }
    }

    class DFA18 extends DFA {

        public DFA18(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 18;
            this.eot = DFA18_eot;
            this.eof = DFA18_eof;
            this.min = DFA18_min;
            this.max = DFA18_max;
            this.accept = DFA18_accept;
            this.special = DFA18_special;
            this.transition = DFA18_transition;
        }
        public String getDescription() {
            return "()* loopback of 313:3: (o= ( '==' | '!=' ) e= relationalExpression )*";
        }
    }
    static final String DFA19_eotS =
        "\16\uffff";
    static final String DFA19_eofS =
        "\1\1\15\uffff";
    static final String DFA19_minS =
        "\1\17\15\uffff";
    static final String DFA19_maxS =
        "\1\62\15\uffff";
    static final String DFA19_acceptS =
        "\1\uffff\1\2\13\uffff\1\1";
    static final String DFA19_specialS =
        "\16\uffff}>";
    static final String[] DFA19_transitionS = {
            "\1\1\3\uffff\3\1\3\uffff\1\1\2\uffff\2\1\4\15\13\uffff\1\1"+
            "\1\uffff\4\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA19_eot = DFA.unpackEncodedString(DFA19_eotS);
    static final short[] DFA19_eof = DFA.unpackEncodedString(DFA19_eofS);
    static final char[] DFA19_min = DFA.unpackEncodedStringToUnsignedChars(DFA19_minS);
    static final char[] DFA19_max = DFA.unpackEncodedStringToUnsignedChars(DFA19_maxS);
    static final short[] DFA19_accept = DFA.unpackEncodedString(DFA19_acceptS);
    static final short[] DFA19_special = DFA.unpackEncodedString(DFA19_specialS);
    static final short[][] DFA19_transition;

    static {
        int numStates = DFA19_transitionS.length;
        DFA19_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA19_transition[i] = DFA.unpackEncodedString(DFA19_transitionS[i]);
        }
    }

    class DFA19 extends DFA {

        public DFA19(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 19;
            this.eot = DFA19_eot;
            this.eof = DFA19_eof;
            this.min = DFA19_min;
            this.max = DFA19_max;
            this.accept = DFA19_accept;
            this.special = DFA19_special;
            this.transition = DFA19_transition;
        }
        public String getDescription() {
            return "()* loopback of 331:3: (o= relationalOp e= additiveExpression )*";
        }
    }
    static final String DFA20_eotS =
        "\17\uffff";
    static final String DFA20_eofS =
        "\1\1\16\uffff";
    static final String DFA20_minS =
        "\1\17\16\uffff";
    static final String DFA20_maxS =
        "\1\62\16\uffff";
    static final String DFA20_acceptS =
        "\1\uffff\1\2\14\uffff\1\1";
    static final String DFA20_specialS =
        "\17\uffff}>";
    static final String[] DFA20_transitionS = {
            "\1\1\3\uffff\3\1\3\uffff\1\1\2\uffff\6\1\2\16\11\uffff\1\1"+
            "\1\uffff\4\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA20_eot = DFA.unpackEncodedString(DFA20_eotS);
    static final short[] DFA20_eof = DFA.unpackEncodedString(DFA20_eofS);
    static final char[] DFA20_min = DFA.unpackEncodedStringToUnsignedChars(DFA20_minS);
    static final char[] DFA20_max = DFA.unpackEncodedStringToUnsignedChars(DFA20_maxS);
    static final short[] DFA20_accept = DFA.unpackEncodedString(DFA20_acceptS);
    static final short[] DFA20_special = DFA.unpackEncodedString(DFA20_specialS);
    static final short[][] DFA20_transition;

    static {
        int numStates = DFA20_transitionS.length;
        DFA20_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA20_transition[i] = DFA.unpackEncodedString(DFA20_transitionS[i]);
        }
    }

    class DFA20 extends DFA {

        public DFA20(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 20;
            this.eot = DFA20_eot;
            this.eof = DFA20_eof;
            this.min = DFA20_min;
            this.max = DFA20_max;
            this.accept = DFA20_accept;
            this.special = DFA20_special;
            this.transition = DFA20_transition;
        }
        public String getDescription() {
            return "()* loopback of 358:3: (o= ( '+' | '-' ) e= multiplicativeExpression )*";
        }
    }
    static final String DFA21_eotS =
        "\20\uffff";
    static final String DFA21_eofS =
        "\1\1\17\uffff";
    static final String DFA21_minS =
        "\1\17\17\uffff";
    static final String DFA21_maxS =
        "\1\62\17\uffff";
    static final String DFA21_acceptS =
        "\1\uffff\1\2\15\uffff\1\1";
    static final String DFA21_specialS =
        "\20\uffff}>";
    static final String[] DFA21_transitionS = {
            "\1\1\3\uffff\3\1\3\uffff\1\1\2\uffff\10\1\2\17\7\uffff\1\1"+
            "\1\uffff\4\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA21_eot = DFA.unpackEncodedString(DFA21_eotS);
    static final short[] DFA21_eof = DFA.unpackEncodedString(DFA21_eofS);
    static final char[] DFA21_min = DFA.unpackEncodedStringToUnsignedChars(DFA21_minS);
    static final char[] DFA21_max = DFA.unpackEncodedStringToUnsignedChars(DFA21_maxS);
    static final short[] DFA21_accept = DFA.unpackEncodedString(DFA21_acceptS);
    static final short[] DFA21_special = DFA.unpackEncodedString(DFA21_specialS);
    static final short[][] DFA21_transition;

    static {
        int numStates = DFA21_transitionS.length;
        DFA21_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA21_transition[i] = DFA.unpackEncodedString(DFA21_transitionS[i]);
        }
    }

    class DFA21 extends DFA {

        public DFA21(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 21;
            this.eot = DFA21_eot;
            this.eof = DFA21_eof;
            this.min = DFA21_min;
            this.max = DFA21_max;
            this.accept = DFA21_accept;
            this.special = DFA21_special;
            this.transition = DFA21_transition;
        }
        public String getDescription() {
            return "()* loopback of 377:3: (o= ( '*' | '/' ) e= unaryExpression )*";
        }
    }
    static final String DFA22_eotS =
        "\14\uffff";
    static final String DFA22_eofS =
        "\14\uffff";
    static final String DFA22_minS =
        "\1\10\13\uffff";
    static final String DFA22_maxS =
        "\1\66\13\uffff";
    static final String DFA22_acceptS =
        "\1\uffff\1\1\1\2\1\3\10\uffff";
    static final String DFA22_specialS =
        "\14\uffff}>";
    static final String[] DFA22_transitionS = {
            "\1\3\2\uffff\3\3\1\uffff\1\3\13\uffff\1\3\6\uffff\1\1\1\2\17"+
            "\uffff\4\3",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA22_eot = DFA.unpackEncodedString(DFA22_eotS);
    static final short[] DFA22_eof = DFA.unpackEncodedString(DFA22_eofS);
    static final char[] DFA22_min = DFA.unpackEncodedStringToUnsignedChars(DFA22_minS);
    static final char[] DFA22_max = DFA.unpackEncodedStringToUnsignedChars(DFA22_maxS);
    static final short[] DFA22_accept = DFA.unpackEncodedString(DFA22_acceptS);
    static final short[] DFA22_special = DFA.unpackEncodedString(DFA22_specialS);
    static final short[][] DFA22_transition;

    static {
        int numStates = DFA22_transitionS.length;
        DFA22_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA22_transition[i] = DFA.unpackEncodedString(DFA22_transitionS[i]);
        }
    }

    class DFA22 extends DFA {

        public DFA22(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 22;
            this.eot = DFA22_eot;
            this.eof = DFA22_eof;
            this.min = DFA22_min;
            this.max = DFA22_max;
            this.accept = DFA22_accept;
            this.special = DFA22_special;
            this.transition = DFA22_transition;
        }
        public String getDescription() {
            return "393:2: ( '+' e= unaryExpression | '-' e= unaryExpression | ue= negationExpression )";
        }
    }
    static final String DFA23_eotS =
        "\12\uffff";
    static final String DFA23_eofS =
        "\12\uffff";
    static final String DFA23_minS =
        "\1\10\11\uffff";
    static final String DFA23_maxS =
        "\1\66\11\uffff";
    static final String DFA23_acceptS =
        "\1\uffff\1\1\1\2\7\uffff";
    static final String DFA23_specialS =
        "\12\uffff}>";
    static final String[] DFA23_transitionS = {
            "\1\2\2\uffff\3\2\1\uffff\1\2\13\uffff\1\2\27\uffff\1\1\3\2",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA23_eot = DFA.unpackEncodedString(DFA23_eotS);
    static final short[] DFA23_eof = DFA.unpackEncodedString(DFA23_eofS);
    static final char[] DFA23_min = DFA.unpackEncodedStringToUnsignedChars(DFA23_minS);
    static final char[] DFA23_max = DFA.unpackEncodedStringToUnsignedChars(DFA23_maxS);
    static final short[] DFA23_accept = DFA.unpackEncodedString(DFA23_acceptS);
    static final short[] DFA23_special = DFA.unpackEncodedString(DFA23_specialS);
    static final short[][] DFA23_transition;

    static {
        int numStates = DFA23_transitionS.length;
        DFA23_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA23_transition[i] = DFA.unpackEncodedString(DFA23_transitionS[i]);
        }
    }

    class DFA23 extends DFA {

        public DFA23(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 23;
            this.eot = DFA23_eot;
            this.eof = DFA23_eof;
            this.min = DFA23_min;
            this.max = DFA23_max;
            this.accept = DFA23_accept;
            this.special = DFA23_special;
            this.transition = DFA23_transition;
        }
        public String getDescription() {
            return "410:2: ( '!' e= negationExpression | p= primary )";
        }
    }
    static final String DFA26_eotS =
        "\24\uffff";
    static final String DFA26_eofS =
        "\1\uffff\1\2\22\uffff";
    static final String DFA26_minS =
        "\2\17\22\uffff";
    static final String DFA26_maxS =
        "\1\17\1\62\22\uffff";
    static final String DFA26_acceptS =
        "\2\uffff\1\1\20\uffff\1\2";
    static final String DFA26_specialS =
        "\24\uffff}>";
    static final String[] DFA26_transitionS = {
            "\1\1",
            "\2\2\2\uffff\4\2\2\uffff\1\2\1\uffff\1\23\12\2\7\uffff\1\2"+
            "\1\uffff\4\2",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA26_eot = DFA.unpackEncodedString(DFA26_eotS);
    static final short[] DFA26_eof = DFA.unpackEncodedString(DFA26_eofS);
    static final char[] DFA26_min = DFA.unpackEncodedStringToUnsignedChars(DFA26_minS);
    static final char[] DFA26_max = DFA.unpackEncodedStringToUnsignedChars(DFA26_maxS);
    static final short[] DFA26_accept = DFA.unpackEncodedString(DFA26_acceptS);
    static final short[] DFA26_special = DFA.unpackEncodedString(DFA26_specialS);
    static final short[][] DFA26_transition;

    static {
        int numStates = DFA26_transitionS.length;
        DFA26_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA26_transition[i] = DFA.unpackEncodedString(DFA26_transitionS[i]);
        }
    }

    class DFA26 extends DFA {

        public DFA26(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 26;
            this.eot = DFA26_eot;
            this.eof = DFA26_eof;
            this.min = DFA26_min;
            this.max = DFA26_max;
            this.accept = DFA26_accept;
            this.special = DFA26_special;
            this.transition = DFA26_transition;
        }
        public String getDescription() {
            return "454:1: symbol returns [Ident ident] : ( variable | methodCall );";
        }
    }
    static final String DFA27_eotS =
        "\22\uffff";
    static final String DFA27_eofS =
        "\1\1\21\uffff";
    static final String DFA27_minS =
        "\1\17\21\uffff";
    static final String DFA27_maxS =
        "\1\62\21\uffff";
    static final String DFA27_acceptS =
        "\1\uffff\1\2\16\uffff\1\1\1\uffff";
    static final String DFA27_specialS =
        "\22\uffff}>";
    static final String[] DFA27_transitionS = {
            "\1\1\1\20\2\uffff\3\1\1\20\2\uffff\1\1\2\uffff\12\1\7\uffff"+
            "\1\1\1\uffff\4\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA27_eot = DFA.unpackEncodedString(DFA27_eotS);
    static final short[] DFA27_eof = DFA.unpackEncodedString(DFA27_eofS);
    static final char[] DFA27_min = DFA.unpackEncodedStringToUnsignedChars(DFA27_minS);
    static final char[] DFA27_max = DFA.unpackEncodedStringToUnsignedChars(DFA27_maxS);
    static final short[] DFA27_accept = DFA.unpackEncodedString(DFA27_acceptS);
    static final short[] DFA27_special = DFA.unpackEncodedString(DFA27_specialS);
    static final short[][] DFA27_transition;

    static {
        int numStates = DFA27_transitionS.length;
        DFA27_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA27_transition[i] = DFA.unpackEncodedString(DFA27_transitionS[i]);
        }
    }

    class DFA27 extends DFA {

        public DFA27(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 27;
            this.eot = DFA27_eot;
            this.eof = DFA27_eof;
            this.min = DFA27_min;
            this.max = DFA27_max;
            this.accept = DFA27_accept;
            this.special = DFA27_special;
            this.transition = DFA27_transition;
        }
        public String getDescription() {
            return "()* loopback of 462:3: ( selector )*";
        }
    }
    static final String DFA28_eotS =
        "\23\uffff";
    static final String DFA28_eofS =
        "\1\1\22\uffff";
    static final String DFA28_minS =
        "\1\17\22\uffff";
    static final String DFA28_maxS =
        "\1\62\22\uffff";
    static final String DFA28_acceptS =
        "\1\uffff\1\2\17\uffff\1\1\1\uffff";
    static final String DFA28_specialS =
        "\23\uffff}>";
    static final String[] DFA28_transitionS = {
            "\1\1\1\21\1\1\1\uffff\3\1\1\21\2\uffff\1\1\2\uffff\12\1\7\uffff"+
            "\1\1\1\uffff\4\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA28_eot = DFA.unpackEncodedString(DFA28_eotS);
    static final short[] DFA28_eof = DFA.unpackEncodedString(DFA28_eofS);
    static final char[] DFA28_min = DFA.unpackEncodedStringToUnsignedChars(DFA28_minS);
    static final char[] DFA28_max = DFA.unpackEncodedStringToUnsignedChars(DFA28_maxS);
    static final short[] DFA28_accept = DFA.unpackEncodedString(DFA28_acceptS);
    static final short[] DFA28_special = DFA.unpackEncodedString(DFA28_specialS);
    static final short[][] DFA28_transition;

    static {
        int numStates = DFA28_transitionS.length;
        DFA28_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA28_transition[i] = DFA.unpackEncodedString(DFA28_transitionS[i]);
        }
    }

    class DFA28 extends DFA {

        public DFA28(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 28;
            this.eot = DFA28_eot;
            this.eof = DFA28_eof;
            this.min = DFA28_min;
            this.max = DFA28_max;
            this.accept = DFA28_accept;
            this.special = DFA28_special;
            this.transition = DFA28_transition;
        }
        public String getDescription() {
            return "()* loopback of 468:9: ( selector )*";
        }
    }
    static final String DFA29_eotS =
        "\24\uffff";
    static final String DFA29_eofS =
        "\1\2\23\uffff";
    static final String DFA29_minS =
        "\1\17\23\uffff";
    static final String DFA29_maxS =
        "\1\62\23\uffff";
    static final String DFA29_acceptS =
        "\1\uffff\1\1\1\2\21\uffff";
    static final String DFA29_specialS =
        "\24\uffff}>";
    static final String[] DFA29_transitionS = {
            "\3\2\1\uffff\4\2\2\uffff\1\2\1\uffff\1\1\12\2\7\uffff\1\2\1"+
            "\uffff\4\2",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA29_eot = DFA.unpackEncodedString(DFA29_eotS);
    static final short[] DFA29_eof = DFA.unpackEncodedString(DFA29_eofS);
    static final char[] DFA29_min = DFA.unpackEncodedStringToUnsignedChars(DFA29_minS);
    static final char[] DFA29_max = DFA.unpackEncodedStringToUnsignedChars(DFA29_maxS);
    static final short[] DFA29_accept = DFA.unpackEncodedString(DFA29_acceptS);
    static final short[] DFA29_special = DFA.unpackEncodedString(DFA29_specialS);
    static final short[][] DFA29_transition;

    static {
        int numStates = DFA29_transitionS.length;
        DFA29_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA29_transition[i] = DFA.unpackEncodedString(DFA29_transitionS[i]);
        }
    }

    class DFA29 extends DFA {

        public DFA29(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 29;
            this.eot = DFA29_eot;
            this.eof = DFA29_eof;
            this.min = DFA29_min;
            this.max = DFA29_max;
            this.accept = DFA29_accept;
            this.special = DFA29_special;
            this.transition = DFA29_transition;
        }
        public String getDescription() {
            return "475:3: ( callArgs )?";
        }
    }
    static final String DFA31_eotS =
        "\15\uffff";
    static final String DFA31_eofS =
        "\15\uffff";
    static final String DFA31_minS =
        "\1\10\14\uffff";
    static final String DFA31_maxS =
        "\1\66\14\uffff";
    static final String DFA31_acceptS =
        "\1\uffff\1\1\12\uffff\1\2";
    static final String DFA31_specialS =
        "\15\uffff}>";
    static final String[] DFA31_transitionS = {
            "\1\1\2\uffff\3\1\1\uffff\1\1\13\uffff\1\1\1\14\5\uffff\2\1"+
            "\17\uffff\4\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA31_eot = DFA.unpackEncodedString(DFA31_eotS);
    static final short[] DFA31_eof = DFA.unpackEncodedString(DFA31_eofS);
    static final char[] DFA31_min = DFA.unpackEncodedStringToUnsignedChars(DFA31_minS);
    static final char[] DFA31_max = DFA.unpackEncodedStringToUnsignedChars(DFA31_maxS);
    static final short[] DFA31_accept = DFA.unpackEncodedString(DFA31_acceptS);
    static final short[] DFA31_special = DFA.unpackEncodedString(DFA31_specialS);
    static final short[][] DFA31_transition;

    static {
        int numStates = DFA31_transitionS.length;
        DFA31_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA31_transition[i] = DFA.unpackEncodedString(DFA31_transitionS[i]);
        }
    }

    class DFA31 extends DFA {

        public DFA31(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 31;
            this.eot = DFA31_eot;
            this.eof = DFA31_eof;
            this.min = DFA31_min;
            this.max = DFA31_max;
            this.accept = DFA31_accept;
            this.special = DFA31_special;
            this.transition = DFA31_transition;
        }
        public String getDescription() {
            return "481:10: ( expressionList )?";
        }
    }
 

    public static final BitSet FOLLOW_program_in_main737 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclarations_in_program759 = new BitSet(new long[]{0x0001BF000000C000L});
    public static final BitSet FOLLOW_scriptBody_in_program772 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_classDeclarations801 = new BitSet(new long[]{0x0000008000000002L});
    public static final BitSet FOLLOW_39_in_classDeclaration824 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_CLASS_IDENT_in_classDeclaration828 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_LBRACE_in_classDeclaration833 = new BitSet(new long[]{0x00001F0002004000L});
    public static final BitSet FOLLOW_attribute_declaration_in_classDeclaration867 = new BitSet(new long[]{0x00001F0002004000L});
    public static final BitSet FOLLOW_method_declaration_in_classDeclaration884 = new BitSet(new long[]{0x00001F0002004000L});
    public static final BitSet FOLLOW_RBRACE_in_classDeclaration905 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_method_declaration925 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_IDENT_in_method_declaration928 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_LPAREN_in_method_declaration932 = new BitSet(new long[]{0x00001F0012004000L});
    public static final BitSet FOLLOW_arglist_in_method_declaration934 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_RPAREN_in_method_declaration936 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_LBRACE_in_method_declaration940 = new BitSet(new long[]{0x0001BF000200C000L});
    public static final BitSet FOLLOW_attribute_declaration_in_method_declaration972 = new BitSet(new long[]{0x0001BF000200C000L});
    public static final BitSet FOLLOW_statement_in_method_declaration988 = new BitSet(new long[]{0x0001A00002008000L});
    public static final BitSet FOLLOW_RBRACE_in_method_declaration1006 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_attribute_declaration1023 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_IDENT_in_attribute_declaration1025 = new BitSet(new long[]{0x0000000000080000L});
    public static final BitSet FOLLOW_SEMI_in_attribute_declaration1029 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_type1055 = new BitSet(new long[]{0x0000000000400002L});
    public static final BitSet FOLLOW_LBRACKET_in_type1081 = new BitSet(new long[]{0x0000000000000100L});
    public static final BitSet FOLLOW_INTLIT_in_type1083 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_RBRACKET_in_type1085 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_arglist1119 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_IDENT_in_arglist1123 = new BitSet(new long[]{0x0000000000100002L});
    public static final BitSet FOLLOW_COMMA_in_arglist1130 = new BitSet(new long[]{0x0001BF000200C000L});
    public static final BitSet FOLLOW_type_in_arglist1134 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_IDENT_in_arglist1138 = new BitSet(new long[]{0x0000000000100002L});
    public static final BitSet FOLLOW_attribute_declaration_in_scriptBody1174 = new BitSet(new long[]{0x0001BF000200C002L});
    public static final BitSet FOLLOW_statement_in_scriptBody1187 = new BitSet(new long[]{0x0001A00002008002L});
    public static final BitSet FOLLOW_assignmentStatement_in_statement1211 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ifStatement_in_statement1220 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_whileStatement_in_statement1229 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_returnStatement_in_statement1238 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variable_in_assignmentStatement1261 = new BitSet(new long[]{0x0000000000020000L});
    public static final BitSet FOLLOW_ASSIGN_in_assignmentStatement1263 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_expression_in_assignmentStatement1267 = new BitSet(new long[]{0x0000000000080000L});
    public static final BitSet FOLLOW_SEMI_in_assignmentStatement1269 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_45_in_ifStatement1288 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_LPAREN_in_ifStatement1290 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_expression_in_ifStatement1294 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_RPAREN_in_ifStatement1306 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_LBRACE_in_ifStatement1308 = new BitSet(new long[]{0x0001A00002008000L});
    public static final BitSet FOLLOW_statement_in_ifStatement1316 = new BitSet(new long[]{0x0001A00002008000L});
    public static final BitSet FOLLOW_RBRACE_in_ifStatement1327 = new BitSet(new long[]{0x0000400000000002L});
    public static final BitSet FOLLOW_46_in_ifStatement1332 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_LBRACE_in_ifStatement1335 = new BitSet(new long[]{0x0001A00002008000L});
    public static final BitSet FOLLOW_statement_in_ifStatement1343 = new BitSet(new long[]{0x0001A00002008000L});
    public static final BitSet FOLLOW_RBRACE_in_ifStatement1353 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_47_in_whileStatement1376 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_LPAREN_in_whileStatement1378 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_expression_in_whileStatement1382 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_RPAREN_in_whileStatement1384 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_LBRACE_in_whileStatement1389 = new BitSet(new long[]{0x0001A00002008000L});
    public static final BitSet FOLLOW_statement_in_whileStatement1402 = new BitSet(new long[]{0x0001A00002008000L});
    public static final BitSet FOLLOW_RBRACE_in_whileStatement1417 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_48_in_returnStatement1432 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_expression_in_returnStatement1436 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalOrExpression_in_expression1458 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression1482 = new BitSet(new long[]{0x0002000000000002L});
    public static final BitSet FOLLOW_49_in_conditionalOrExpression1490 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression1494 = new BitSet(new long[]{0x0002000000000002L});
    public static final BitSet FOLLOW_equalityExpression_in_conditionalAndExpression1525 = new BitSet(new long[]{0x0004000000000002L});
    public static final BitSet FOLLOW_50_in_conditionalAndExpression1533 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_equalityExpression_in_conditionalAndExpression1537 = new BitSet(new long[]{0x0004000000000002L});
    public static final BitSet FOLLOW_relationalExpression_in_equalityExpression1572 = new BitSet(new long[]{0x0000000020200002L});
    public static final BitSet FOLLOW_set_in_equalityExpression1582 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_relationalExpression_in_equalityExpression1601 = new BitSet(new long[]{0x0000000020200002L});
    public static final BitSet FOLLOW_additiveExpression_in_relationalExpression1636 = new BitSet(new long[]{0x00000003C0000002L});
    public static final BitSet FOLLOW_relationalOp_in_relationalExpression1646 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_additiveExpression_in_relationalExpression1654 = new BitSet(new long[]{0x00000003C0000002L});
    public static final BitSet FOLLOW_set_in_relationalOp0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression1717 = new BitSet(new long[]{0x0000000C00000002L});
    public static final BitSet FOLLOW_set_in_additiveExpression1727 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression1745 = new BitSet(new long[]{0x0000000C00000002L});
    public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression1783 = new BitSet(new long[]{0x0000003000000002L});
    public static final BitSet FOLLOW_set_in_multiplicativeExpression1793 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression1811 = new BitSet(new long[]{0x0000003000000002L});
    public static final BitSet FOLLOW_PLUS_in_unaryExpression1845 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression1849 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_MINUS_in_unaryExpression1859 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression1863 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_negationExpression_in_unaryExpression1875 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_51_in_negationExpression1909 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_negationExpression_in_negationExpression1913 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primary_in_negationExpression1922 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_primary1955 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_expression_in_primary1959 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_RPAREN_in_primary1961 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_literal_in_primary1970 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_symbol_in_primary1979 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_52_in_primary1986 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_creator_in_primary1990 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CLASS_IDENT_in_creator2020 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_LPAREN_in_creator2022 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_RPAREN_in_creator2024 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INTLIT_in_literal2057 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOUBLELIT_in_literal2069 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CHARLIT_in_literal2081 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STRINGLIT_in_literal2093 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_boollit_in_literal2105 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_boollit0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variable_in_symbol2150 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_methodCall_in_symbol2157 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_methodCall2178 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_callArgs_in_methodCall2182 = new BitSet(new long[]{0x0000000000410002L});
    public static final BitSet FOLLOW_selector_in_methodCall2190 = new BitSet(new long[]{0x0000000000410002L});
    public static final BitSet FOLLOW_IDENT_in_variable2218 = new BitSet(new long[]{0x0000000000410000L});
    public static final BitSet FOLLOW_selector_in_variable2221 = new BitSet(new long[]{0x0000000000410002L});
    public static final BitSet FOLLOW_LBRACKET_in_selector2245 = new BitSet(new long[]{0x0000000000000100L});
    public static final BitSet FOLLOW_INTLIT_in_selector2247 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_RBRACKET_in_selector2249 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_selector2256 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_IDENT_in_selector2258 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_callArgs_in_selector2265 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_callArgs2294 = new BitSet(new long[]{0x0078000C1800B900L});
    public static final BitSet FOLLOW_expressionList_in_callArgs2297 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_RPAREN_in_callArgs2304 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_expressionList2329 = new BitSet(new long[]{0x0000000000100002L});
    public static final BitSet FOLLOW_COMMA_in_expressionList2337 = new BitSet(new long[]{0x0078000C0800B900L});
    public static final BitSet FOLLOW_expression_in_expressionList2341 = new BitSet(new long[]{0x0000000000100002L});

}